From 5219e23d52f6eb03cdb54556ab8155a9ebf5368b Mon Sep 17 00:00:00 2001 From: clevertension Date: Wed, 11 Oct 2017 22:38:02 +0800 Subject: [PATCH 1/7] add h2 support --- .../worker/cpu/dao/CpuMetricH2DAO.java | 30 ++++++- .../agentjvm/worker/gc/dao/GCMetricH2DAO.java | 28 +++++- .../heartbeat/dao/InstanceHeartBeatH2DAO.java | 50 ++++++++++- .../worker/memory/dao/MemoryMetricH2DAO.java | 29 ++++++- .../memorypool/dao/MemoryPoolMetricH2DAO.java | 29 ++++++- .../application/dao/ApplicationH2DAO.java | 47 +++++++--- .../worker/global/dao/GlobalTraceH2DAO.java | 20 ++++- .../performance/dao/InstPerformanceH2DAO.java | 21 ++++- .../component/dao/NodeComponentH2DAO.java | 20 ++++- .../node/mapping/dao/NodeMappingH2DAO.java | 20 ++++- .../noderef/dao/NodeReferenceH2DAO.java | 20 ++++- .../segment/cost/dao/SegmentCostH2DAO.java | 28 +++++- .../segment/origin/dao/SegmentH2DAO.java | 20 ++++- .../service/entry/dao/ServiceEntryH2DAO.java | 57 +++++++++++- .../serviceref/dao/ServiceReferenceH2DAO.java | 82 +++++++++++++++-- .../src/main/resources/application.yml | 27 +++--- .../apm/collector/client/h2/H2Client.java | 87 +++++++++++++++---- .../client/zookeeper/ZookeeperClient.java | 8 ++ .../zookeeper/ClusterZKDataMonitor.java | 8 +- .../collector/storage/h2/StorageH2Config.java | 7 ++ .../storage/h2/StorageH2ConfigParser.java | 15 +++- .../storage/h2/StorageH2ModuleDefine.java | 2 +- .../apm/collector/storage/h2/dao/H2DAO.java | 37 ++++++++ .../storage/h2/define/H2StorageInstaller.java | 43 ++++++++- 24 files changed, 666 insertions(+), 69 deletions(-) create mode 100644 apm-collector/apm-collector-storage/src/main/java/org/skywalking/apm/collector/storage/h2/StorageH2Config.java diff --git a/apm-collector/apm-collector-agentjvm/src/main/java/org/skywalking/apm/collector/agentjvm/worker/cpu/dao/CpuMetricH2DAO.java b/apm-collector/apm-collector-agentjvm/src/main/java/org/skywalking/apm/collector/agentjvm/worker/cpu/dao/CpuMetricH2DAO.java index cdd08577d..065f4c918 100644 --- a/apm-collector/apm-collector-agentjvm/src/main/java/org/skywalking/apm/collector/agentjvm/worker/cpu/dao/CpuMetricH2DAO.java +++ b/apm-collector/apm-collector-agentjvm/src/main/java/org/skywalking/apm/collector/agentjvm/worker/cpu/dao/CpuMetricH2DAO.java @@ -1,9 +1,37 @@ package org.skywalking.apm.collector.agentjvm.worker.cpu.dao; +import org.skywalking.apm.collector.core.stream.Data; +import org.skywalking.apm.collector.storage.define.DataDefine; +import org.skywalking.apm.collector.storage.define.jvm.CpuMetricTable; +import org.skywalking.apm.collector.storage.define.jvm.GCMetricTable; import org.skywalking.apm.collector.storage.h2.dao.H2DAO; +import org.skywalking.apm.collector.stream.worker.impl.dao.IPersistenceDAO; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import java.util.HashMap; +import java.util.Map; /** * @author pengys5 */ -public class CpuMetricH2DAO extends H2DAO implements ICpuMetricDAO { +public class CpuMetricH2DAO extends H2DAO implements ICpuMetricDAO, IPersistenceDAO, Map> { + private final Logger logger = LoggerFactory.getLogger(CpuMetricH2DAO.class); + @Override public Data get(String id, DataDefine dataDefine) { + return null; + } + + @Override public Map prepareBatchInsert(Data data) { + Map source = new HashMap<>(); + source.put(CpuMetricTable.COLUMN_INSTANCE_ID, data.getDataInteger(0)); + source.put(CpuMetricTable.COLUMN_USAGE_PERCENT, data.getDataDouble(0)); + source.put(CpuMetricTable.COLUMN_TIME_BUCKET, data.getDataLong(0)); + + logger.debug("prepare cpu metric batch insert, id: {}", data.getDataString(0)); + return source; + } + + @Override public Map prepareBatchUpdate(Data data) { + return null; + } } diff --git a/apm-collector/apm-collector-agentjvm/src/main/java/org/skywalking/apm/collector/agentjvm/worker/gc/dao/GCMetricH2DAO.java b/apm-collector/apm-collector-agentjvm/src/main/java/org/skywalking/apm/collector/agentjvm/worker/gc/dao/GCMetricH2DAO.java index c1d5f1e70..b58a40158 100644 --- a/apm-collector/apm-collector-agentjvm/src/main/java/org/skywalking/apm/collector/agentjvm/worker/gc/dao/GCMetricH2DAO.java +++ b/apm-collector/apm-collector-agentjvm/src/main/java/org/skywalking/apm/collector/agentjvm/worker/gc/dao/GCMetricH2DAO.java @@ -1,9 +1,35 @@ package org.skywalking.apm.collector.agentjvm.worker.gc.dao; +import org.skywalking.apm.collector.core.stream.Data; +import org.skywalking.apm.collector.storage.define.DataDefine; +import org.skywalking.apm.collector.storage.define.jvm.GCMetricTable; +import org.skywalking.apm.collector.storage.define.jvm.MemoryMetricTable; import org.skywalking.apm.collector.storage.h2.dao.H2DAO; +import org.skywalking.apm.collector.stream.worker.impl.dao.IPersistenceDAO; + +import java.util.HashMap; +import java.util.Map; /** * @author pengys5 */ -public class GCMetricH2DAO extends H2DAO implements IGCMetricDAO { +public class GCMetricH2DAO extends H2DAO implements IGCMetricDAO, IPersistenceDAO, Map> { + @Override public Data get(String id, DataDefine dataDefine) { + return null; + } + + @Override public Map prepareBatchInsert(Data data) { + Map source = new HashMap<>(); + source.put(GCMetricTable.COLUMN_INSTANCE_ID, data.getDataInteger(0)); + source.put(GCMetricTable.COLUMN_PHRASE, data.getDataInteger(1)); + source.put(GCMetricTable.COLUMN_COUNT, data.getDataLong(0)); + source.put(GCMetricTable.COLUMN_TIME, data.getDataLong(1)); + source.put(GCMetricTable.COLUMN_TIME_BUCKET, data.getDataLong(2)); + + return source; + } + + @Override public Map prepareBatchUpdate(Data data) { + return null; + } } diff --git a/apm-collector/apm-collector-agentjvm/src/main/java/org/skywalking/apm/collector/agentjvm/worker/heartbeat/dao/InstanceHeartBeatH2DAO.java b/apm-collector/apm-collector-agentjvm/src/main/java/org/skywalking/apm/collector/agentjvm/worker/heartbeat/dao/InstanceHeartBeatH2DAO.java index 2a63de395..fc10e863e 100644 --- a/apm-collector/apm-collector-agentjvm/src/main/java/org/skywalking/apm/collector/agentjvm/worker/heartbeat/dao/InstanceHeartBeatH2DAO.java +++ b/apm-collector/apm-collector-agentjvm/src/main/java/org/skywalking/apm/collector/agentjvm/worker/heartbeat/dao/InstanceHeartBeatH2DAO.java @@ -1,9 +1,57 @@ package org.skywalking.apm.collector.agentjvm.worker.heartbeat.dao; +import org.elasticsearch.action.get.GetResponse; +import org.elasticsearch.action.index.IndexRequestBuilder; +import org.elasticsearch.action.update.UpdateRequestBuilder; +import org.skywalking.apm.collector.client.h2.H2Client; +import org.skywalking.apm.collector.client.h2.H2ClientException; +import org.skywalking.apm.collector.core.framework.UnexpectedException; +import org.skywalking.apm.collector.core.stream.Data; +import org.skywalking.apm.collector.storage.define.DataDefine; +import org.skywalking.apm.collector.storage.define.register.InstanceTable; import org.skywalking.apm.collector.storage.h2.dao.H2DAO; +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.util.HashMap; +import java.util.Map; /** * @author pengys5 */ -public class InstanceHeartBeatH2DAO extends H2DAO implements IInstanceHeartBeatDAO { +public class InstanceHeartBeatH2DAO extends H2DAO implements IInstanceHeartBeatDAO, IPersistenceDAO, Map> { + private final Logger logger = LoggerFactory.getLogger(InstanceHeartBeatEsDAO.class); + + @Override public Data get(String id, DataDefine dataDefine) { + H2Client client = getClient(); + String sql = "select " + InstanceTable.COLUMN_INSTANCE_ID + "," + InstanceTable.COLUMN_HEARTBEAT_TIME + + " from " + InstanceTable.TABLE + " where " + InstanceTable.COLUMN_INSTANCE_ID + "=?"; + Object[] params = new Object[] {id}; + ResultSet rs = null; + try { + rs = client.executeQuery(sql, params); + Data data = dataDefine.build(id); + data.setDataInteger(0, rs.getInt(1)); + data.setDataLong(0, rs.getLong(2)); + return data; + } catch (SQLException | H2ClientException e) { + logger.error(e.getMessage(), e); + } finally { + client.closeResultSet(rs); + } + return null; + } + + @Override public Map prepareBatchInsert(Data data) { + throw new UnexpectedException("There is no need to merge stream data with database data."); + } + + @Override public Map prepareBatchUpdate(Data data) { + Map source = new HashMap<>(); + source.put(InstanceTable.COLUMN_HEARTBEAT_TIME, data.getDataLong(0)); + return source; + } } diff --git a/apm-collector/apm-collector-agentjvm/src/main/java/org/skywalking/apm/collector/agentjvm/worker/memory/dao/MemoryMetricH2DAO.java b/apm-collector/apm-collector-agentjvm/src/main/java/org/skywalking/apm/collector/agentjvm/worker/memory/dao/MemoryMetricH2DAO.java index 16f6d407b..3afaeaac8 100644 --- a/apm-collector/apm-collector-agentjvm/src/main/java/org/skywalking/apm/collector/agentjvm/worker/memory/dao/MemoryMetricH2DAO.java +++ b/apm-collector/apm-collector-agentjvm/src/main/java/org/skywalking/apm/collector/agentjvm/worker/memory/dao/MemoryMetricH2DAO.java @@ -1,9 +1,36 @@ package org.skywalking.apm.collector.agentjvm.worker.memory.dao; +import org.skywalking.apm.collector.core.stream.Data; +import org.skywalking.apm.collector.storage.define.DataDefine; +import org.skywalking.apm.collector.storage.define.jvm.MemoryMetricTable; import org.skywalking.apm.collector.storage.h2.dao.H2DAO; +import org.skywalking.apm.collector.stream.worker.impl.dao.IPersistenceDAO; + +import java.util.HashMap; +import java.util.Map; /** * @author pengys5 */ -public class MemoryMetricH2DAO extends H2DAO implements IMemoryMetricDAO { +public class MemoryMetricH2DAO extends H2DAO implements IMemoryMetricDAO, IPersistenceDAO, Map> { + @Override public Data get(String id, DataDefine dataDefine) { + return null; + } + + @Override public Map prepareBatchInsert(Data data) { + Map source = new HashMap<>(); + source.put(MemoryMetricTable.COLUMN_APPLICATION_INSTANCE_ID, data.getDataInteger(0)); + source.put(MemoryMetricTable.COLUMN_IS_HEAP, data.getDataBoolean(0)); + source.put(MemoryMetricTable.COLUMN_INIT, data.getDataLong(0)); + source.put(MemoryMetricTable.COLUMN_MAX, data.getDataLong(1)); + source.put(MemoryMetricTable.COLUMN_USED, data.getDataLong(2)); + source.put(MemoryMetricTable.COLUMN_COMMITTED, data.getDataLong(3)); + source.put(MemoryMetricTable.COLUMN_TIME_BUCKET, data.getDataLong(4)); + + return source; + } + + @Override public Map prepareBatchUpdate(Data data) { + return null; + } } diff --git a/apm-collector/apm-collector-agentjvm/src/main/java/org/skywalking/apm/collector/agentjvm/worker/memorypool/dao/MemoryPoolMetricH2DAO.java b/apm-collector/apm-collector-agentjvm/src/main/java/org/skywalking/apm/collector/agentjvm/worker/memorypool/dao/MemoryPoolMetricH2DAO.java index 200f9bb16..7cbd236bb 100644 --- a/apm-collector/apm-collector-agentjvm/src/main/java/org/skywalking/apm/collector/agentjvm/worker/memorypool/dao/MemoryPoolMetricH2DAO.java +++ b/apm-collector/apm-collector-agentjvm/src/main/java/org/skywalking/apm/collector/agentjvm/worker/memorypool/dao/MemoryPoolMetricH2DAO.java @@ -1,9 +1,36 @@ package org.skywalking.apm.collector.agentjvm.worker.memorypool.dao; +import org.skywalking.apm.collector.core.stream.Data; +import org.skywalking.apm.collector.storage.define.DataDefine; +import org.skywalking.apm.collector.storage.define.jvm.MemoryPoolMetricTable; import org.skywalking.apm.collector.storage.h2.dao.H2DAO; +import org.skywalking.apm.collector.stream.worker.impl.dao.IPersistenceDAO; + +import java.util.HashMap; +import java.util.Map; /** * @author pengys5 */ -public class MemoryPoolMetricH2DAO extends H2DAO implements IMemoryPoolMetricDAO { +public class MemoryPoolMetricH2DAO extends H2DAO implements IMemoryPoolMetricDAO, IPersistenceDAO, Map> { + @Override public Data get(String id, DataDefine dataDefine) { + return null; + } + + @Override public Map prepareBatchInsert(Data data) { + Map source = new HashMap<>(); + source.put(MemoryPoolMetricTable.COLUMN_INSTANCE_ID, data.getDataInteger(0)); + source.put(MemoryPoolMetricTable.COLUMN_POOL_TYPE, data.getDataInteger(1)); + source.put(MemoryPoolMetricTable.COLUMN_INIT, data.getDataLong(0)); + source.put(MemoryPoolMetricTable.COLUMN_MAX, data.getDataLong(1)); + source.put(MemoryPoolMetricTable.COLUMN_USED, data.getDataLong(2)); + source.put(MemoryPoolMetricTable.COLUMN_COMMITTED, data.getDataLong(3)); + source.put(MemoryPoolMetricTable.COLUMN_TIME_BUCKET, data.getDataLong(4)); + + return source; + } + + @Override public Map prepareBatchUpdate(Data data) { + return null; + } } 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 0081c0294..53337184f 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 @@ -1,28 +1,47 @@ package org.skywalking.apm.collector.agentregister.worker.application.dao; +import org.skywalking.apm.collector.client.h2.H2ClientException; import org.skywalking.apm.collector.storage.define.register.ApplicationDataDefine; import org.skywalking.apm.collector.client.h2.H2Client; +import org.skywalking.apm.collector.storage.define.register.ApplicationTable; import org.skywalking.apm.collector.storage.h2.dao.H2DAO; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; /** * @author pengys5 */ public class ApplicationH2DAO extends H2DAO implements IApplicationDAO { + private final Logger logger = LoggerFactory.getLogger(ApplicationH2DAO.class); + @Override + public int getApplicationId(String applicationCode) { + logger.info("get the application id with application code = {}", applicationCode); + String sql = "select " + ApplicationTable.COLUMN_APPLICATION_ID + " from " + + ApplicationTable.TABLE + " where " + ApplicationTable.COLUMN_APPLICATION_CODE + "='" + applicationCode + "'"; - @Override public int getApplicationId(String applicationCode) { + return getIntValueBySQL(sql); + } + + @Override + public int getMaxApplicationId() { + return getMaxId(ApplicationTable.TABLE, ApplicationTable.COLUMN_APPLICATION_ID); + } + + @Override + public int getMinApplicationId() { + return getMinId(ApplicationTable.TABLE, ApplicationTable.COLUMN_APPLICATION_ID); + } + + @Override + public void save(ApplicationDataDefine.Application application) { + String insertSQL = "insert into " + ApplicationTable.TABLE + "(" + ApplicationTable.COLUMN_APPLICATION_ID + + "," + ApplicationTable.COLUMN_APPLICATION_CODE + ") values (?, ?)"; H2Client client = getClient(); - return 100; - } - - @Override public int getMaxApplicationId() { - return 0; - } - - @Override public int getMinApplicationId() { - return 0; - } - - @Override public void save(ApplicationDataDefine.Application application) { - + Object[] params = new Object[] {application.getApplicationId(), application.getApplicationCode()}; + try { + client.execute(insertSQL, params); + } catch (H2ClientException e) { + logger.error(e.getMessage(), e); + } } } diff --git a/apm-collector/apm-collector-agentstream/src/main/java/org/skywalking/apm/collector/agentstream/worker/global/dao/GlobalTraceH2DAO.java b/apm-collector/apm-collector-agentstream/src/main/java/org/skywalking/apm/collector/agentstream/worker/global/dao/GlobalTraceH2DAO.java index ea48e612f..d17002aa0 100644 --- a/apm-collector/apm-collector-agentstream/src/main/java/org/skywalking/apm/collector/agentstream/worker/global/dao/GlobalTraceH2DAO.java +++ b/apm-collector/apm-collector-agentstream/src/main/java/org/skywalking/apm/collector/agentstream/worker/global/dao/GlobalTraceH2DAO.java @@ -1,9 +1,27 @@ package org.skywalking.apm.collector.agentstream.worker.global.dao; +import org.skywalking.apm.collector.agentstream.worker.instance.performance.dao.InstPerformanceH2DAO; +import org.skywalking.apm.collector.core.stream.Data; +import org.skywalking.apm.collector.storage.define.DataDefine; import org.skywalking.apm.collector.storage.h2.dao.H2DAO; +import org.skywalking.apm.collector.stream.worker.impl.dao.IPersistenceDAO; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import java.util.Map; /** * @author pengys5 */ -public class GlobalTraceH2DAO extends H2DAO implements IGlobalTraceDAO { +public class GlobalTraceH2DAO extends H2DAO implements IGlobalTraceDAO, IPersistenceDAO, Map> { + private final Logger logger = LoggerFactory.getLogger(GlobalTraceH2DAO.class); + @Override public Data get(String id, DataDefine dataDefine) { + return null; + } + @Override public Map prepareBatchInsert(Data data) { + return null; + } + @Override public Map prepareBatchUpdate(Data data) { + return null; + } } diff --git a/apm-collector/apm-collector-agentstream/src/main/java/org/skywalking/apm/collector/agentstream/worker/instance/performance/dao/InstPerformanceH2DAO.java b/apm-collector/apm-collector-agentstream/src/main/java/org/skywalking/apm/collector/agentstream/worker/instance/performance/dao/InstPerformanceH2DAO.java index 9dbe1800c..bb7b9fb04 100644 --- a/apm-collector/apm-collector-agentstream/src/main/java/org/skywalking/apm/collector/agentstream/worker/instance/performance/dao/InstPerformanceH2DAO.java +++ b/apm-collector/apm-collector-agentstream/src/main/java/org/skywalking/apm/collector/agentstream/worker/instance/performance/dao/InstPerformanceH2DAO.java @@ -1,10 +1,27 @@ package org.skywalking.apm.collector.agentstream.worker.instance.performance.dao; +import org.skywalking.apm.collector.agentstream.worker.node.component.dao.NodeComponentH2DAO; +import org.skywalking.apm.collector.core.stream.Data; +import org.skywalking.apm.collector.storage.define.DataDefine; import org.skywalking.apm.collector.storage.h2.dao.H2DAO; +import org.skywalking.apm.collector.stream.worker.impl.dao.IPersistenceDAO; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import java.util.Map; /** * @author pengys5 */ -public class InstPerformanceH2DAO extends H2DAO implements IInstPerformanceDAO { - +public class InstPerformanceH2DAO extends H2DAO implements IInstPerformanceDAO, IPersistenceDAO, Map> { + private final Logger logger = LoggerFactory.getLogger(InstPerformanceH2DAO.class); + @Override public Data get(String id, DataDefine dataDefine) { + return null; + } + @Override public Map prepareBatchInsert(Data data) { + return null; + } + @Override public Map prepareBatchUpdate(Data data) { + return null; + } } diff --git a/apm-collector/apm-collector-agentstream/src/main/java/org/skywalking/apm/collector/agentstream/worker/node/component/dao/NodeComponentH2DAO.java b/apm-collector/apm-collector-agentstream/src/main/java/org/skywalking/apm/collector/agentstream/worker/node/component/dao/NodeComponentH2DAO.java index 5e08b3445..870f656e6 100644 --- a/apm-collector/apm-collector-agentstream/src/main/java/org/skywalking/apm/collector/agentstream/worker/node/component/dao/NodeComponentH2DAO.java +++ b/apm-collector/apm-collector-agentstream/src/main/java/org/skywalking/apm/collector/agentstream/worker/node/component/dao/NodeComponentH2DAO.java @@ -1,10 +1,26 @@ package org.skywalking.apm.collector.agentstream.worker.node.component.dao; +import org.skywalking.apm.collector.core.stream.Data; +import org.skywalking.apm.collector.storage.define.DataDefine; import org.skywalking.apm.collector.storage.h2.dao.H2DAO; +import org.skywalking.apm.collector.stream.worker.impl.dao.IPersistenceDAO; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import java.util.Map; /** * @author pengys5 */ -public class NodeComponentH2DAO extends H2DAO implements INodeComponentDAO { - +public class NodeComponentH2DAO extends H2DAO implements INodeComponentDAO, IPersistenceDAO, Map> { + private final Logger logger = LoggerFactory.getLogger(NodeComponentH2DAO.class); + @Override public Data get(String id, DataDefine dataDefine) { + return null; + } + @Override public Map prepareBatchInsert(Data data) { + return null; + } + @Override public Map prepareBatchUpdate(Data data) { + return null; + } } 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 045d0738e..e5cb8709a 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 @@ -1,9 +1,27 @@ package org.skywalking.apm.collector.agentstream.worker.node.mapping.dao; +import org.skywalking.apm.collector.agentstream.worker.node.component.dao.NodeComponentH2DAO; +import org.skywalking.apm.collector.core.stream.Data; +import org.skywalking.apm.collector.storage.define.DataDefine; import org.skywalking.apm.collector.storage.h2.dao.H2DAO; +import org.skywalking.apm.collector.stream.worker.impl.dao.IPersistenceDAO; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import java.util.Map; /** * @author pengys5 */ -public class NodeMappingH2DAO extends H2DAO implements INodeMappingDAO { +public class NodeMappingH2DAO extends H2DAO implements INodeMappingDAO, IPersistenceDAO, Map> { + private final Logger logger = LoggerFactory.getLogger(NodeComponentH2DAO.class); + @Override public Data get(String id, DataDefine dataDefine) { + return null; + } + @Override public Map prepareBatchInsert(Data data) { + return null; + } + @Override public Map prepareBatchUpdate(Data data) { + return null; + } } 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 30a206c3e..7fe20ff63 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,9 +1,27 @@ package org.skywalking.apm.collector.agentstream.worker.noderef.dao; +import org.skywalking.apm.collector.agentstream.worker.segment.cost.dao.SegmentCostH2DAO; +import org.skywalking.apm.collector.core.stream.Data; +import org.skywalking.apm.collector.storage.define.DataDefine; import org.skywalking.apm.collector.storage.h2.dao.H2DAO; +import org.skywalking.apm.collector.stream.worker.impl.dao.IPersistenceDAO; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import java.util.Map; /** * @author pengys5 */ -public class NodeReferenceH2DAO extends H2DAO implements INodeReferenceDAO { +public class NodeReferenceH2DAO extends H2DAO implements INodeReferenceDAO, IPersistenceDAO, Map> { + private final Logger logger = LoggerFactory.getLogger(NodeReferenceH2DAO.class); + @Override public Data get(String id, DataDefine dataDefine) { + return null; + } + @Override public Map prepareBatchInsert(Data data) { + return null; + } + @Override public Map prepareBatchUpdate(Data data) { + return null; + } } diff --git a/apm-collector/apm-collector-agentstream/src/main/java/org/skywalking/apm/collector/agentstream/worker/segment/cost/dao/SegmentCostH2DAO.java b/apm-collector/apm-collector-agentstream/src/main/java/org/skywalking/apm/collector/agentstream/worker/segment/cost/dao/SegmentCostH2DAO.java index 63a6c78c5..1fb2e7181 100644 --- a/apm-collector/apm-collector-agentstream/src/main/java/org/skywalking/apm/collector/agentstream/worker/segment/cost/dao/SegmentCostH2DAO.java +++ b/apm-collector/apm-collector-agentstream/src/main/java/org/skywalking/apm/collector/agentstream/worker/segment/cost/dao/SegmentCostH2DAO.java @@ -1,10 +1,34 @@ package org.skywalking.apm.collector.agentstream.worker.segment.cost.dao; +import org.skywalking.apm.collector.agentstream.worker.service.entry.dao.ServiceEntryH2DAO; +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.service.ServiceEntryTable; +import org.skywalking.apm.collector.storage.define.serviceref.ServiceReferenceTable; import org.skywalking.apm.collector.storage.h2.dao.H2DAO; +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.util.HashMap; +import java.util.Map; /** * @author pengys5 */ -public class SegmentCostH2DAO extends H2DAO implements ISegmentCostDAO { - +public class SegmentCostH2DAO extends H2DAO implements ISegmentCostDAO, IPersistenceDAO, Map> { + private final Logger logger = LoggerFactory.getLogger(SegmentCostH2DAO.class); + @Override public Data get(String id, DataDefine dataDefine) { + return null; + } + @Override public Map prepareBatchInsert(Data data) { + return null; + } + @Override public Map prepareBatchUpdate(Data data) { + return null; + } } diff --git a/apm-collector/apm-collector-agentstream/src/main/java/org/skywalking/apm/collector/agentstream/worker/segment/origin/dao/SegmentH2DAO.java b/apm-collector/apm-collector-agentstream/src/main/java/org/skywalking/apm/collector/agentstream/worker/segment/origin/dao/SegmentH2DAO.java index 363088b87..37054c67b 100644 --- a/apm-collector/apm-collector-agentstream/src/main/java/org/skywalking/apm/collector/agentstream/worker/segment/origin/dao/SegmentH2DAO.java +++ b/apm-collector/apm-collector-agentstream/src/main/java/org/skywalking/apm/collector/agentstream/worker/segment/origin/dao/SegmentH2DAO.java @@ -1,9 +1,27 @@ package org.skywalking.apm.collector.agentstream.worker.segment.origin.dao; +import org.skywalking.apm.collector.agentstream.worker.segment.cost.dao.SegmentCostH2DAO; +import org.skywalking.apm.collector.core.stream.Data; +import org.skywalking.apm.collector.storage.define.DataDefine; import org.skywalking.apm.collector.storage.h2.dao.H2DAO; +import org.skywalking.apm.collector.stream.worker.impl.dao.IPersistenceDAO; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import java.util.Map; /** * @author pengys5 */ -public class SegmentH2DAO extends H2DAO implements ISegmentDAO { +public class SegmentH2DAO extends H2DAO implements ISegmentDAO, IPersistenceDAO, Map> { + private final Logger logger = LoggerFactory.getLogger(SegmentCostH2DAO.class); + @Override public Data get(String id, DataDefine dataDefine) { + return null; + } + @Override public Map prepareBatchInsert(Data data) { + return null; + } + @Override public Map prepareBatchUpdate(Data data) { + return null; + } } diff --git a/apm-collector/apm-collector-agentstream/src/main/java/org/skywalking/apm/collector/agentstream/worker/service/entry/dao/ServiceEntryH2DAO.java b/apm-collector/apm-collector-agentstream/src/main/java/org/skywalking/apm/collector/agentstream/worker/service/entry/dao/ServiceEntryH2DAO.java index fb2cd96c7..a2650151b 100644 --- a/apm-collector/apm-collector-agentstream/src/main/java/org/skywalking/apm/collector/agentstream/worker/service/entry/dao/ServiceEntryH2DAO.java +++ b/apm-collector/apm-collector-agentstream/src/main/java/org/skywalking/apm/collector/agentstream/worker/service/entry/dao/ServiceEntryH2DAO.java @@ -1,9 +1,64 @@ package org.skywalking.apm.collector.agentstream.worker.service.entry.dao; +import org.skywalking.apm.collector.agentstream.worker.serviceref.dao.ServiceReferenceH2DAO; +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.service.ServiceEntryTable; +import org.skywalking.apm.collector.storage.define.serviceref.ServiceReferenceTable; import org.skywalking.apm.collector.storage.h2.dao.H2DAO; +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.util.HashMap; +import java.util.Map; /** * @author pengys5 */ -public class ServiceEntryH2DAO extends H2DAO implements IServiceEntryDAO { +public class ServiceEntryH2DAO extends H2DAO implements IServiceEntryDAO, IPersistenceDAO, Map> { + private final Logger logger = LoggerFactory.getLogger(ServiceEntryH2DAO.class); + @Override public Data get(String id, DataDefine dataDefine) { + H2Client client = getClient(); + String sql = "select * from " + ServiceReferenceTable.TABLE + " where " + ServiceReferenceTable.COLUMN_ENTRY_SERVICE_ID + "=?"; + Object[] params = new Object[] {id}; + ResultSet rs = null; + try { + rs = client.executeQuery(sql, params); + Data data = dataDefine.build(id); + data.setDataInteger(0, rs.getInt(ServiceEntryTable.COLUMN_APPLICATION_ID)); + data.setDataInteger(1, rs.getInt(ServiceEntryTable.COLUMN_ENTRY_SERVICE_ID)); + data.setDataString(1, rs.getString(ServiceEntryTable.COLUMN_ENTRY_SERVICE_NAME)); + data.setDataLong(0, rs.getLong(ServiceEntryTable.COLUMN_REGISTER_TIME)); + data.setDataLong(1, rs.getLong(ServiceEntryTable.COLUMN_NEWEST_TIME)); + return data; + } catch (SQLException | H2ClientException e) { + logger.error(e.getMessage(), e); + } finally { + client.closeResultSet(rs); + } + return null; + } + @Override public Map prepareBatchInsert(Data data) { + Map source = new HashMap<>(); + source.put(ServiceEntryTable.COLUMN_APPLICATION_ID, data.getDataInteger(0)); + source.put(ServiceEntryTable.COLUMN_ENTRY_SERVICE_ID, data.getDataInteger(1)); + source.put(ServiceEntryTable.COLUMN_ENTRY_SERVICE_NAME, data.getDataString(1)); + source.put(ServiceEntryTable.COLUMN_REGISTER_TIME, data.getDataLong(0)); + source.put(ServiceEntryTable.COLUMN_NEWEST_TIME, data.getDataLong(1)); + return source; + } + @Override public Map prepareBatchUpdate(Data data) { + Map source = new HashMap<>(); + source.put(ServiceEntryTable.COLUMN_APPLICATION_ID, data.getDataInteger(0)); + source.put(ServiceEntryTable.COLUMN_ENTRY_SERVICE_ID, data.getDataInteger(1)); + source.put(ServiceEntryTable.COLUMN_ENTRY_SERVICE_NAME, data.getDataString(1)); + source.put(ServiceEntryTable.COLUMN_REGISTER_TIME, data.getDataLong(0)); + source.put(ServiceEntryTable.COLUMN_NEWEST_TIME, data.getDataLong(1)); + return source; + } } diff --git a/apm-collector/apm-collector-agentstream/src/main/java/org/skywalking/apm/collector/agentstream/worker/serviceref/dao/ServiceReferenceH2DAO.java b/apm-collector/apm-collector-agentstream/src/main/java/org/skywalking/apm/collector/agentstream/worker/serviceref/dao/ServiceReferenceH2DAO.java index 33d2957de..6b17bf8ec 100644 --- a/apm-collector/apm-collector-agentstream/src/main/java/org/skywalking/apm/collector/agentstream/worker/serviceref/dao/ServiceReferenceH2DAO.java +++ b/apm-collector/apm-collector-agentstream/src/main/java/org/skywalking/apm/collector/agentstream/worker/serviceref/dao/ServiceReferenceH2DAO.java @@ -1,24 +1,94 @@ package org.skywalking.apm.collector.agentstream.worker.serviceref.dao; +import org.skywalking.apm.collector.client.h2.H2Client; +import org.skywalking.apm.collector.client.h2.H2ClientException; +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.skywalking.apm.collector.stream.worker.impl.dao.IPersistenceDAO; import org.skywalking.apm.collector.core.stream.Data; import org.skywalking.apm.collector.storage.define.DataDefine; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import java.sql.ResultSet; +import java.sql.SQLException; +import java.util.HashMap; +import java.util.Map; /** * @author pengys5 */ -public class ServiceReferenceH2DAO extends H2DAO implements IServiceReferenceDAO, IPersistenceDAO { - +public class ServiceReferenceH2DAO extends H2DAO implements IServiceReferenceDAO, IPersistenceDAO, Map> { + private final Logger logger = LoggerFactory.getLogger(ServiceReferenceH2DAO.class); @Override public Data get(String id, DataDefine dataDefine) { + H2Client client = getClient(); + String sql = "select * from " + ServiceReferenceTable.TABLE + " where " + ServiceReferenceTable.COLUMN_ENTRY_SERVICE_ID + "=?"; + Object[] params = new Object[] {id}; + ResultSet rs = null; + try { + rs = client.executeQuery(sql, params); + Data data = dataDefine.build(id); + data.setDataInteger(0, rs.getInt(ServiceReferenceTable.COLUMN_ENTRY_SERVICE_ID)); + data.setDataString(1, rs.getString(ServiceReferenceTable.COLUMN_ENTRY_SERVICE_NAME)); + data.setDataInteger(1, rs.getInt(ServiceReferenceTable.COLUMN_FRONT_SERVICE_ID)); + data.setDataString(2, rs.getString(ServiceReferenceTable.COLUMN_FRONT_SERVICE_NAME)); + data.setDataInteger(2, rs.getInt(ServiceReferenceTable.COLUMN_BEHIND_SERVICE_ID)); + data.setDataString(3, rs.getString(ServiceReferenceTable.COLUMN_BEHIND_SERVICE_NAME)); + data.setDataLong(0, rs.getLong(ServiceReferenceTable.COLUMN_S1_LTE)); + data.setDataLong(1, rs.getLong(ServiceReferenceTable.COLUMN_S3_LTE)); + data.setDataLong(2, rs.getLong(ServiceReferenceTable.COLUMN_S5_LTE)); + data.setDataLong(3, rs.getLong(ServiceReferenceTable.COLUMN_S5_GT)); + data.setDataLong(4, rs.getLong(ServiceReferenceTable.COLUMN_SUMMARY)); + data.setDataLong(5, rs.getLong(ServiceReferenceTable.COLUMN_ERROR)); + data.setDataLong(6, rs.getLong(ServiceReferenceTable.COLUMN_COST_SUMMARY)); + data.setDataLong(7, rs.getLong(ServiceReferenceTable.COLUMN_TIME_BUCKET)); + return data; + } catch (SQLException | H2ClientException e) { + logger.error(e.getMessage(), e); + } finally { + client.closeResultSet(rs); + } return null; } - @Override public String prepareBatchInsert(Data data) { - return null; + @Override public Map prepareBatchInsert(Data data) { + Map source = new HashMap<>(); + source.put(ServiceReferenceTable.COLUMN_ENTRY_SERVICE_ID, data.getDataInteger(0)); + source.put(ServiceReferenceTable.COLUMN_ENTRY_SERVICE_NAME, data.getDataString(1)); + source.put(ServiceReferenceTable.COLUMN_FRONT_SERVICE_ID, data.getDataInteger(1)); + source.put(ServiceReferenceTable.COLUMN_FRONT_SERVICE_NAME, data.getDataString(2)); + source.put(ServiceReferenceTable.COLUMN_BEHIND_SERVICE_ID, data.getDataInteger(2)); + source.put(ServiceReferenceTable.COLUMN_BEHIND_SERVICE_NAME, data.getDataString(3)); + source.put(ServiceReferenceTable.COLUMN_S1_LTE, data.getDataLong(0)); + source.put(ServiceReferenceTable.COLUMN_S3_LTE, data.getDataLong(1)); + source.put(ServiceReferenceTable.COLUMN_S5_LTE, data.getDataLong(2)); + source.put(ServiceReferenceTable.COLUMN_S5_GT, data.getDataLong(3)); + source.put(ServiceReferenceTable.COLUMN_SUMMARY, data.getDataLong(4)); + source.put(ServiceReferenceTable.COLUMN_ERROR, data.getDataLong(5)); + source.put(ServiceReferenceTable.COLUMN_COST_SUMMARY, data.getDataLong(6)); + source.put(ServiceReferenceTable.COLUMN_TIME_BUCKET, data.getDataLong(7)); + + return source; } - @Override public String prepareBatchUpdate(Data data) { - return null; + @Override public Map prepareBatchUpdate(Data data) { + Map source = new HashMap<>(); + source.put(ServiceReferenceTable.COLUMN_ENTRY_SERVICE_ID, data.getDataInteger(0)); + source.put(ServiceReferenceTable.COLUMN_ENTRY_SERVICE_NAME, data.getDataString(1)); + source.put(ServiceReferenceTable.COLUMN_FRONT_SERVICE_ID, data.getDataInteger(1)); + source.put(ServiceReferenceTable.COLUMN_FRONT_SERVICE_NAME, data.getDataString(2)); + source.put(ServiceReferenceTable.COLUMN_BEHIND_SERVICE_ID, data.getDataInteger(2)); + source.put(ServiceReferenceTable.COLUMN_BEHIND_SERVICE_NAME, data.getDataString(3)); + source.put(ServiceReferenceTable.COLUMN_S1_LTE, data.getDataLong(0)); + source.put(ServiceReferenceTable.COLUMN_S3_LTE, data.getDataLong(1)); + source.put(ServiceReferenceTable.COLUMN_S5_LTE, data.getDataLong(2)); + source.put(ServiceReferenceTable.COLUMN_S5_GT, data.getDataLong(3)); + source.put(ServiceReferenceTable.COLUMN_SUMMARY, data.getDataLong(4)); + source.put(ServiceReferenceTable.COLUMN_ERROR, data.getDataLong(5)); + source.put(ServiceReferenceTable.COLUMN_COST_SUMMARY, data.getDataLong(6)); + source.put(ServiceReferenceTable.COLUMN_TIME_BUCKET, data.getDataLong(7)); + + return source; } } diff --git a/apm-collector/apm-collector-boot/src/main/resources/application.yml b/apm-collector/apm-collector-boot/src/main/resources/application.yml index c9e94f239..e8a4837c7 100644 --- a/apm-collector/apm-collector-boot/src/main/resources/application.yml +++ b/apm-collector/apm-collector-boot/src/main/resources/application.yml @@ -4,30 +4,35 @@ cluster: sessionTimeout: 100000 agent_server: jetty: - host: localhost + host: 0.0.0.0 port: 10800 context_path: / agent_stream: grpc: - host: localhost + host: 192.168.10.13 port: 11800 jetty: - host: localhost + host: 0.0.0.0 port: 12800 context_path: / ui: jetty: - host: localhost + host: 0.0.0.0 port: 12800 context_path: / collector_inside: grpc: - host: localhost + host: 127.0.0.1 port: 11800 +#storage: +# elasticsearch: +# cluster_name: CollectorDBCluster +# cluster_transport_sniffer: true +# cluster_nodes: localhost:9300 +# index_shards_number: 2 +# index_replicas_number: 0 storage: - elasticsearch: - cluster_name: CollectorDBCluster - cluster_transport_sniffer: true - cluster_nodes: localhost:9300 - index_shards_number: 2 - index_replicas_number: 0 + h2: + url: jdbc:h2:~/collector + user_name: sa + password: sa \ No newline at end of file diff --git a/apm-collector/apm-collector-client/src/main/java/org/skywalking/apm/collector/client/h2/H2Client.java b/apm-collector/apm-collector-client/src/main/java/org/skywalking/apm/collector/client/h2/H2Client.java index 65960cbef..035383716 100644 --- a/apm-collector/apm-collector-client/src/main/java/org/skywalking/apm/collector/client/h2/H2Client.java +++ b/apm-collector/apm-collector-client/src/main/java/org/skywalking/apm/collector/client/h2/H2Client.java @@ -1,10 +1,9 @@ package org.skywalking.apm.collector.client.h2; -import java.sql.Connection; -import java.sql.DriverManager; -import java.sql.ResultSet; -import java.sql.SQLException; -import java.sql.Statement; +import java.sql.*; + +import org.h2.jdbcx.JdbcConnectionPool; +import org.h2.util.IOUtils; import org.skywalking.apm.collector.core.client.Client; import org.slf4j.Logger; import org.slf4j.LoggerFactory; @@ -16,25 +15,49 @@ public class H2Client implements Client { private final Logger logger = LoggerFactory.getLogger(H2Client.class); + private JdbcConnectionPool cp; private Connection conn; + private String url; + private String userName; + private String password; + + public H2Client() { + this.url = "jdbc:h2:mem:collector"; + this.userName = ""; + this.password = ""; + } + + public H2Client(String url, String userName, String password) { + this.url = url; + this.userName = userName; + this.password = password; + } @Override public void initialize() throws H2ClientException { try { - Class.forName("org.h2.Driver"); - conn = DriverManager.getConnection("jdbc:h2:mem:collector"); - } catch (ClassNotFoundException | SQLException e) { + cp = JdbcConnectionPool. + create(this.url, this.userName, this.password); + conn = cp.getConnection(); + } catch (Exception e) { throw new H2ClientException(e.getMessage(), e); } } @Override public void shutdown() { + if (cp != null) { + cp.dispose(); + } + IOUtils.closeSilently(conn); + } + public Connection getConnection() throws H2ClientException { + return conn; } public void execute(String sql) throws H2ClientException { Statement statement = null; try { - statement = conn.createStatement(); + statement = getConnection().createStatement(); statement.execute(sql); statement.closeOnCompletion(); } catch (SQLException e) { @@ -42,17 +65,51 @@ public class H2Client implements Client { } } - public void executeQuery(String sql) throws H2ClientException { - Statement statement = null; + public ResultSet executeQuery(String sql, Object[] params) throws H2ClientException { + logger.info("execute query with result: {}", sql); + PreparedStatement statement; + ResultSet rs; try { - statement = conn.createStatement(); - ResultSet rs = statement.executeQuery(sql); - while (rs.next()) { - logger.debug(rs.getString("ADDRESS") + "," + rs.getString("DATA")); + statement = getConnection().prepareStatement(sql); + if (params != null) { + for (int i = 0; i < params.length; i++) { + statement.setObject(i+1, params[i]); + } } + rs = statement.executeQuery(); statement.closeOnCompletion(); } catch (SQLException e) { throw new H2ClientException(e.getMessage(), e); } + return rs; + } + + public boolean execute(String sql, Object[] params) throws H2ClientException { + logger.info("execute insert/update/delete: {}", sql); + PreparedStatement statement; + boolean flag; + try { + statement = getConnection().prepareStatement(sql); + if (params != null) { + for (int i = 0; i < params.length; i++) { + statement.setObject(i+1, params[i]); + } + } + flag = statement.execute(); + statement.closeOnCompletion(); + } catch (SQLException e) { + throw new H2ClientException(e.getMessage(), e); + } + return flag; + } + + public void closeResultSet(ResultSet rs) { + if (rs != null) { + try { + rs.close(); + } catch (SQLException e) { + logger.error(e.getMessage(), e); + } + } } } diff --git a/apm-collector/apm-collector-client/src/main/java/org/skywalking/apm/collector/client/zookeeper/ZookeeperClient.java b/apm-collector/apm-collector-client/src/main/java/org/skywalking/apm/collector/client/zookeeper/ZookeeperClient.java index 3077cc958..7bd2bdab8 100644 --- a/apm-collector/apm-collector-client/src/main/java/org/skywalking/apm/collector/client/zookeeper/ZookeeperClient.java +++ b/apm-collector/apm-collector-client/src/main/java/org/skywalking/apm/collector/client/zookeeper/ZookeeperClient.java @@ -60,6 +60,14 @@ public class ZookeeperClient implements Client { } } + public void delete(final String path, int version) throws ZookeeperClientException { + try { + zk.delete(path, version); + } catch (KeeperException | InterruptedException e) { + throw new ZookeeperClientException(e.getMessage(), e); + } + } + public byte[] getData(String path, boolean watch, Stat stat) throws ZookeeperClientException { try { return zk.getData(path, watch, stat); diff --git a/apm-collector/apm-collector-cluster/src/main/java/org/skywalking/apm/collector/cluster/zookeeper/ClusterZKDataMonitor.java b/apm-collector/apm-collector-cluster/src/main/java/org/skywalking/apm/collector/cluster/zookeeper/ClusterZKDataMonitor.java index c209852e0..3238fe63e 100644 --- a/apm-collector/apm-collector-cluster/src/main/java/org/skywalking/apm/collector/cluster/zookeeper/ClusterZKDataMonitor.java +++ b/apm-collector/apm-collector-cluster/src/main/java/org/skywalking/apm/collector/cluster/zookeeper/ClusterZKDataMonitor.java @@ -97,9 +97,15 @@ public class ClusterZKDataMonitor implements DataMonitor, Watcher { client.getChildren(next.getKey(), true); String serverPath = next.getKey() + "/" + value.getHostPort(); - if (client.exists(serverPath, false) == null) { + Stat stat = client.exists(serverPath, false); + if (stat != null) { + client.delete(serverPath, stat.getVersion()); + } + stat = client.exists(serverPath, false); + if (stat == null) { setData(serverPath, contextPath); } else { + client.delete(serverPath, stat.getVersion()); throw new ClusterNodeExistException("current address: " + value.getHostPort() + " has been registered, check the host and port configuration or wait a moment."); } } diff --git a/apm-collector/apm-collector-storage/src/main/java/org/skywalking/apm/collector/storage/h2/StorageH2Config.java b/apm-collector/apm-collector-storage/src/main/java/org/skywalking/apm/collector/storage/h2/StorageH2Config.java new file mode 100644 index 000000000..29fdee86d --- /dev/null +++ b/apm-collector/apm-collector-storage/src/main/java/org/skywalking/apm/collector/storage/h2/StorageH2Config.java @@ -0,0 +1,7 @@ +package org.skywalking.apm.collector.storage.h2; + +public class StorageH2Config { + public static String URL; + public static String USER_NAME; + public static String PASSWORD; +} diff --git a/apm-collector/apm-collector-storage/src/main/java/org/skywalking/apm/collector/storage/h2/StorageH2ConfigParser.java b/apm-collector/apm-collector-storage/src/main/java/org/skywalking/apm/collector/storage/h2/StorageH2ConfigParser.java index 72f7b561f..f4c0f3379 100644 --- a/apm-collector/apm-collector-storage/src/main/java/org/skywalking/apm/collector/storage/h2/StorageH2ConfigParser.java +++ b/apm-collector/apm-collector-storage/src/main/java/org/skywalking/apm/collector/storage/h2/StorageH2ConfigParser.java @@ -3,12 +3,25 @@ package org.skywalking.apm.collector.storage.h2; import java.util.Map; import org.skywalking.apm.collector.core.config.ConfigParseException; import org.skywalking.apm.collector.core.module.ModuleConfigParser; +import org.skywalking.apm.collector.core.util.ObjectUtils; +import org.skywalking.apm.collector.core.util.StringUtils; /** * @author pengys5 */ public class StorageH2ConfigParser implements ModuleConfigParser { - + private static final String URL = "url"; + public static final String USER_NAME = "user_name"; + public static final String PASSWORD = "password"; @Override public void parse(Map config) throws ConfigParseException { + if (ObjectUtils.isNotEmpty(config) && StringUtils.isNotEmpty(config.get(URL))) { + StorageH2Config.URL = (String)config.get(URL); + } + if (ObjectUtils.isNotEmpty(config) && StringUtils.isNotEmpty(config.get(USER_NAME))) { + StorageH2Config.USER_NAME = (String)config.get(USER_NAME); + } + if (ObjectUtils.isNotEmpty(config) && StringUtils.isNotEmpty(config.get(PASSWORD))) { + StorageH2Config.PASSWORD = (String)config.get(PASSWORD); + } } } diff --git a/apm-collector/apm-collector-storage/src/main/java/org/skywalking/apm/collector/storage/h2/StorageH2ModuleDefine.java b/apm-collector/apm-collector-storage/src/main/java/org/skywalking/apm/collector/storage/h2/StorageH2ModuleDefine.java index 99575e2b2..a75a1c1fa 100644 --- a/apm-collector/apm-collector-storage/src/main/java/org/skywalking/apm/collector/storage/h2/StorageH2ModuleDefine.java +++ b/apm-collector/apm-collector-storage/src/main/java/org/skywalking/apm/collector/storage/h2/StorageH2ModuleDefine.java @@ -33,7 +33,7 @@ public class StorageH2ModuleDefine extends StorageModuleDefine { } @Override protected Client createClient() { - return new H2Client(); + return new H2Client(StorageH2Config.URL, StorageH2Config.USER_NAME, StorageH2Config.PASSWORD); } @Override public StorageInstaller storageInstaller() { diff --git a/apm-collector/apm-collector-storage/src/main/java/org/skywalking/apm/collector/storage/h2/dao/H2DAO.java b/apm-collector/apm-collector-storage/src/main/java/org/skywalking/apm/collector/storage/h2/dao/H2DAO.java index a9c9ddb5a..1d703e954 100644 --- a/apm-collector/apm-collector-storage/src/main/java/org/skywalking/apm/collector/storage/h2/dao/H2DAO.java +++ b/apm-collector/apm-collector-storage/src/main/java/org/skywalking/apm/collector/storage/h2/dao/H2DAO.java @@ -1,10 +1,47 @@ package org.skywalking.apm.collector.storage.h2.dao; import org.skywalking.apm.collector.client.h2.H2Client; +import org.skywalking.apm.collector.client.h2.H2ClientException; import org.skywalking.apm.collector.storage.dao.DAO; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import java.sql.ResultSet; +import java.sql.SQLException; /** * @author pengys5 */ public abstract class H2DAO extends DAO { + private final Logger logger = LoggerFactory.getLogger(H2DAO.class); + public final int getMaxId(String tableName, String columnName) { + String sql = "select max(" + columnName + ") from " + tableName; + return getIntValueBySQL(sql); + } + + public final int getMinId(String tableName, String columnName) { + String sql = "select min(" + columnName + ") from " + tableName; + return getIntValueBySQL(sql); + } + + public final int getIntValueBySQL(String sql) { + H2Client client = getClient(); + ResultSet rs = null; + try { + rs = client.executeQuery(sql, null); + if (rs.next()) { + int id = rs.getInt(1); + if (id == Integer.MAX_VALUE || id == Integer.MIN_VALUE) { + return 0; + } else { + return id; + } + } + } catch (SQLException | H2ClientException e) { + logger.error(e.getMessage(), e); + } finally { + client.closeResultSet(rs); + } + return 0; + } } diff --git a/apm-collector/apm-collector-storage/src/main/java/org/skywalking/apm/collector/storage/h2/define/H2StorageInstaller.java b/apm-collector/apm-collector-storage/src/main/java/org/skywalking/apm/collector/storage/h2/define/H2StorageInstaller.java index 3244808a5..12718a66c 100644 --- a/apm-collector/apm-collector-storage/src/main/java/org/skywalking/apm/collector/storage/h2/define/H2StorageInstaller.java +++ b/apm-collector/apm-collector-storage/src/main/java/org/skywalking/apm/collector/storage/h2/define/H2StorageInstaller.java @@ -1,6 +1,10 @@ package org.skywalking.apm.collector.storage.h2.define; +import java.sql.ResultSet; +import java.sql.SQLException; import java.util.List; + +import org.h2.util.IOUtils; import org.skywalking.apm.collector.client.h2.H2Client; import org.skywalking.apm.collector.client.h2.H2ClientException; import org.skywalking.apm.collector.core.client.Client; @@ -8,12 +12,16 @@ import org.skywalking.apm.collector.core.storage.StorageException; import org.skywalking.apm.collector.core.storage.StorageInstallException; import org.skywalking.apm.collector.core.storage.StorageInstaller; import org.skywalking.apm.collector.core.storage.TableDefine; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; /** * @author pengys5 */ public class H2StorageInstaller extends StorageInstaller { + private final Logger logger = LoggerFactory.getLogger(H2StorageInstaller.class); + @Override protected void defineFilter(List tableDefines) { int size = tableDefines.size(); for (int i = size - 1; i >= 0; i--) { @@ -24,11 +32,36 @@ public class H2StorageInstaller extends StorageInstaller { } @Override protected boolean isExists(Client client, TableDefine tableDefine) throws StorageException { + H2Client h2Client = (H2Client)client; + ResultSet rs = null; + try { + logger.info("check if table {} exist ", tableDefine.getName()); + rs = h2Client.getConnection().getMetaData().getTables(null, null, tableDefine.getName().toUpperCase(), null); + if (rs.next()) { + return true; + } + } catch (SQLException | H2ClientException e) { + throw new StorageInstallException(e.getMessage(), e); + } finally { + try { + if (rs != null) { + rs.close(); + } + } catch (SQLException e) { + throw new StorageInstallException(e.getMessage(), e); + } + } return false; } @Override protected boolean deleteTable(Client client, TableDefine tableDefine) throws StorageException { - return false; + H2Client h2Client = (H2Client)client; + try { + h2Client.execute("drop table if exists " + tableDefine.getName()); + return true; + } catch (H2ClientException e) { + throw new StorageInstallException(e.getMessage(), e); + } } @Override protected boolean createTable(Client client, TableDefine tableDefine) throws StorageException { @@ -41,14 +74,16 @@ public class H2StorageInstaller extends StorageInstaller { h2TableDefine.getColumnDefines().forEach(columnDefine -> { H2ColumnDefine h2ColumnDefine = (H2ColumnDefine)columnDefine; if (h2ColumnDefine.getType().equals(H2ColumnDefine.Type.Varchar.name())) { - sqlBuilder.append(h2ColumnDefine.getName()).append(" ").append(h2ColumnDefine.getType()).append("(255)"); + sqlBuilder.append(h2ColumnDefine.getName()).append(" ").append(h2ColumnDefine.getType()).append("(255),"); } else { - sqlBuilder.append(h2ColumnDefine.getName()).append(" ").append(h2ColumnDefine.getType()); + sqlBuilder.append(h2ColumnDefine.getName()).append(" ").append(h2ColumnDefine.getType()).append(","); } }); - + //remove last comma + sqlBuilder.delete(sqlBuilder.length() - 1, sqlBuilder.length()); sqlBuilder.append(")"); try { + logger.info("create h2 table with sql {}", sqlBuilder); h2Client.execute(sqlBuilder.toString()); } catch (H2ClientException e) { throw new StorageInstallException(e.getMessage(), e); From bc38a56da0a00dc309e4b48d1c1fa8071c940ce4 Mon Sep 17 00:00:00 2001 From: clevertension Date: Thu, 12 Oct 2017 21:19:53 +0800 Subject: [PATCH 2/7] add h2 support ga --- .../worker/cpu/dao/CpuMetricH2DAO.java | 15 +- .../agentjvm/worker/gc/dao/GCMetricH2DAO.java | 15 +- .../heartbeat/dao/InstanceHeartBeatH2DAO.java | 45 +++--- .../worker/memory/dao/MemoryMetricH2DAO.java | 14 +- .../memorypool/dao/MemoryPoolMetricH2DAO.java | 14 +- .../application/dao/ApplicationH2DAO.java | 11 +- .../worker/instance/dao/InstanceH2DAO.java | 72 +++++++++- .../worker/global/dao/GlobalTraceH2DAO.java | 31 +++- .../performance/dao/InstPerformanceH2DAO.java | 61 +++++++- .../component/dao/NodeComponentH2DAO.java | 70 ++++++++- .../node/mapping/dao/NodeMappingH2DAO.java | 57 +++++++- .../noderef/dao/NodeReferenceH2DAO.java | 10 +- .../segment/cost/dao/SegmentCostH2DAO.java | 34 +++-- .../segment/origin/dao/SegmentH2DAO.java | 21 ++- .../service/entry/dao/ServiceEntryH2DAO.java | 35 +++-- .../serviceref/dao/ServiceReferenceH2DAO.java | 78 +++++----- .../src/main/resources/application.yml | 8 +- .../apm/collector/client/h2/H2Client.java | 28 ++-- .../collector/storage/h2/dao/BatchH2DAO.java | 63 +++++++- .../apm/collector/storage/h2/dao/H2DAO.java | 34 ++++- .../storage/h2/define/H2SqlEntity.java | 22 +++ .../storage/h2/define/H2StorageInstaller.java | 9 +- .../collector/ui/dao/ApplicationH2DAO.java | 25 +++- .../apm/collector/ui/dao/CpuMetricH2DAO.java | 81 +++++++++++ .../apm/collector/ui/dao/GCMetricH2DAO.java | 9 +- .../ui/dao/InstPerformanceH2DAO.java | 132 ++++++++++++++++- .../apm/collector/ui/dao/InstanceH2DAO.java | 134 ++++++++++++++++-- .../collector/ui/dao/NodeComponentH2DAO.java | 52 ++++++- .../collector/ui/dao/NodeMappingH2DAO.java | 48 ++++++- .../collector/ui/dao/NodeReferenceH2DAO.java | 63 +++++++- .../ui/service/InstanceHealthService.java | 8 +- 31 files changed, 1093 insertions(+), 206 deletions(-) create mode 100644 apm-collector/apm-collector-storage/src/main/java/org/skywalking/apm/collector/storage/h2/define/H2SqlEntity.java create mode 100644 apm-collector/apm-collector-ui/src/main/java/org/skywalking/apm/collector/ui/dao/CpuMetricH2DAO.java diff --git a/apm-collector/apm-collector-agentjvm/src/main/java/org/skywalking/apm/collector/agentjvm/worker/cpu/dao/CpuMetricH2DAO.java b/apm-collector/apm-collector-agentjvm/src/main/java/org/skywalking/apm/collector/agentjvm/worker/cpu/dao/CpuMetricH2DAO.java index 065f4c918..169dec800 100644 --- a/apm-collector/apm-collector-agentjvm/src/main/java/org/skywalking/apm/collector/agentjvm/worker/cpu/dao/CpuMetricH2DAO.java +++ b/apm-collector/apm-collector-agentjvm/src/main/java/org/skywalking/apm/collector/agentjvm/worker/cpu/dao/CpuMetricH2DAO.java @@ -3,8 +3,8 @@ package org.skywalking.apm.collector.agentjvm.worker.cpu.dao; import org.skywalking.apm.collector.core.stream.Data; import org.skywalking.apm.collector.storage.define.DataDefine; import org.skywalking.apm.collector.storage.define.jvm.CpuMetricTable; -import org.skywalking.apm.collector.storage.define.jvm.GCMetricTable; 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; @@ -15,23 +15,28 @@ import java.util.Map; /** * @author pengys5 */ -public class CpuMetricH2DAO extends H2DAO implements ICpuMetricDAO, IPersistenceDAO, Map> { +public class CpuMetricH2DAO extends H2DAO implements ICpuMetricDAO, IPersistenceDAO { private final Logger logger = LoggerFactory.getLogger(CpuMetricH2DAO.class); @Override public Data get(String id, DataDefine dataDefine) { return null; } - @Override public Map prepareBatchInsert(Data data) { + @Override public H2SqlEntity prepareBatchInsert(Data data) { + H2SqlEntity entity = new H2SqlEntity(); Map source = new HashMap<>(); + source.put("id", data.getDataString(0)); source.put(CpuMetricTable.COLUMN_INSTANCE_ID, data.getDataInteger(0)); source.put(CpuMetricTable.COLUMN_USAGE_PERCENT, data.getDataDouble(0)); source.put(CpuMetricTable.COLUMN_TIME_BUCKET, data.getDataLong(0)); logger.debug("prepare cpu metric batch insert, id: {}", data.getDataString(0)); - return source; + String sql = getBatchInsertSql(CpuMetricTable.TABLE, source.keySet()); + entity.setSql(sql); + entity.setParams(source.values().toArray(new Object[0])); + return entity; } - @Override public Map prepareBatchUpdate(Data data) { + @Override public H2SqlEntity prepareBatchUpdate(Data data) { return null; } } diff --git a/apm-collector/apm-collector-agentjvm/src/main/java/org/skywalking/apm/collector/agentjvm/worker/gc/dao/GCMetricH2DAO.java b/apm-collector/apm-collector-agentjvm/src/main/java/org/skywalking/apm/collector/agentjvm/worker/gc/dao/GCMetricH2DAO.java index b58a40158..268762ec9 100644 --- a/apm-collector/apm-collector-agentjvm/src/main/java/org/skywalking/apm/collector/agentjvm/worker/gc/dao/GCMetricH2DAO.java +++ b/apm-collector/apm-collector-agentjvm/src/main/java/org/skywalking/apm/collector/agentjvm/worker/gc/dao/GCMetricH2DAO.java @@ -3,8 +3,8 @@ package org.skywalking.apm.collector.agentjvm.worker.gc.dao; import org.skywalking.apm.collector.core.stream.Data; import org.skywalking.apm.collector.storage.define.DataDefine; import org.skywalking.apm.collector.storage.define.jvm.GCMetricTable; -import org.skywalking.apm.collector.storage.define.jvm.MemoryMetricTable; 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 java.util.HashMap; @@ -13,23 +13,28 @@ import java.util.Map; /** * @author pengys5 */ -public class GCMetricH2DAO extends H2DAO implements IGCMetricDAO, IPersistenceDAO, Map> { +public class GCMetricH2DAO extends H2DAO implements IGCMetricDAO, IPersistenceDAO { @Override public Data get(String id, DataDefine dataDefine) { return null; } - @Override public Map prepareBatchInsert(Data data) { + @Override public H2SqlEntity prepareBatchInsert(Data data) { + H2SqlEntity entity = new H2SqlEntity(); Map source = new HashMap<>(); + source.put("id", data.getDataString(0)); source.put(GCMetricTable.COLUMN_INSTANCE_ID, data.getDataInteger(0)); source.put(GCMetricTable.COLUMN_PHRASE, data.getDataInteger(1)); source.put(GCMetricTable.COLUMN_COUNT, data.getDataLong(0)); source.put(GCMetricTable.COLUMN_TIME, data.getDataLong(1)); source.put(GCMetricTable.COLUMN_TIME_BUCKET, data.getDataLong(2)); - return source; + String sql = getBatchInsertSql(GCMetricTable.TABLE, source.keySet()); + entity.setSql(sql); + entity.setParams(source.values().toArray(new Object[0])); + return entity; } - @Override public Map prepareBatchUpdate(Data data) { + @Override public H2SqlEntity prepareBatchUpdate(Data data) { return null; } } diff --git a/apm-collector/apm-collector-agentjvm/src/main/java/org/skywalking/apm/collector/agentjvm/worker/heartbeat/dao/InstanceHeartBeatH2DAO.java b/apm-collector/apm-collector-agentjvm/src/main/java/org/skywalking/apm/collector/agentjvm/worker/heartbeat/dao/InstanceHeartBeatH2DAO.java index fc10e863e..9a6cd29ca 100644 --- a/apm-collector/apm-collector-agentjvm/src/main/java/org/skywalking/apm/collector/agentjvm/worker/heartbeat/dao/InstanceHeartBeatH2DAO.java +++ b/apm-collector/apm-collector-agentjvm/src/main/java/org/skywalking/apm/collector/agentjvm/worker/heartbeat/dao/InstanceHeartBeatH2DAO.java @@ -1,8 +1,5 @@ package org.skywalking.apm.collector.agentjvm.worker.heartbeat.dao; -import org.elasticsearch.action.get.GetResponse; -import org.elasticsearch.action.index.IndexRequestBuilder; -import org.elasticsearch.action.update.UpdateRequestBuilder; import org.skywalking.apm.collector.client.h2.H2Client; import org.skywalking.apm.collector.client.h2.H2ClientException; import org.skywalking.apm.collector.core.framework.UnexpectedException; @@ -10,48 +7,52 @@ import org.skywalking.apm.collector.core.stream.Data; import org.skywalking.apm.collector.storage.define.DataDefine; import org.skywalking.apm.collector.storage.define.register.InstanceTable; 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.util.HashMap; -import java.util.Map; +import java.text.MessageFormat; +import java.util.*; /** * @author pengys5 */ -public class InstanceHeartBeatH2DAO extends H2DAO implements IInstanceHeartBeatDAO, IPersistenceDAO, Map> { +public class InstanceHeartBeatH2DAO extends H2DAO implements IInstanceHeartBeatDAO, IPersistenceDAO { private final Logger logger = LoggerFactory.getLogger(InstanceHeartBeatEsDAO.class); - + private static final String GET_INSTANCE_HEARTBEAT_SQL = "select * from {0} where {1} = ?"; @Override public Data get(String id, DataDefine dataDefine) { H2Client client = getClient(); - String sql = "select " + InstanceTable.COLUMN_INSTANCE_ID + "," + InstanceTable.COLUMN_HEARTBEAT_TIME + - " from " + InstanceTable.TABLE + " where " + InstanceTable.COLUMN_INSTANCE_ID + "=?"; - Object[] params = new Object[] {id}; - ResultSet rs = null; - try { - rs = client.executeQuery(sql, params); - Data data = dataDefine.build(id); - data.setDataInteger(0, rs.getInt(1)); - data.setDataLong(0, rs.getLong(2)); - return data; + String sql = MessageFormat.format(GET_INSTANCE_HEARTBEAT_SQL, InstanceTable.TABLE, InstanceTable.COLUMN_INSTANCE_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(InstanceTable.COLUMN_INSTANCE_ID)); + data.setDataLong(0, rs.getLong(InstanceTable.COLUMN_HEARTBEAT_TIME)); + return data; + } } catch (SQLException | H2ClientException e) { logger.error(e.getMessage(), e); - } finally { - client.closeResultSet(rs); } return null; } - @Override public Map prepareBatchInsert(Data data) { + @Override public H2SqlEntity prepareBatchInsert(Data data) { throw new UnexpectedException("There is no need to merge stream data with database data."); } - @Override public Map prepareBatchUpdate(Data data) { + @Override public H2SqlEntity prepareBatchUpdate(Data data) { + H2SqlEntity entity = new H2SqlEntity(); Map source = new HashMap<>(); source.put(InstanceTable.COLUMN_HEARTBEAT_TIME, data.getDataLong(0)); - return source; + String sql = getBatchUpdateSql(InstanceTable.TABLE, source.keySet(), InstanceTable.COLUMN_APPLICATION_ID); + entity.setSql(sql); + List params = new ArrayList<>(source.values()); + params.add(data.getDataString(0)); + entity.setParams(params.toArray(new Object[0])); + return entity; } } diff --git a/apm-collector/apm-collector-agentjvm/src/main/java/org/skywalking/apm/collector/agentjvm/worker/memory/dao/MemoryMetricH2DAO.java b/apm-collector/apm-collector-agentjvm/src/main/java/org/skywalking/apm/collector/agentjvm/worker/memory/dao/MemoryMetricH2DAO.java index 3afaeaac8..1f15524a3 100644 --- a/apm-collector/apm-collector-agentjvm/src/main/java/org/skywalking/apm/collector/agentjvm/worker/memory/dao/MemoryMetricH2DAO.java +++ b/apm-collector/apm-collector-agentjvm/src/main/java/org/skywalking/apm/collector/agentjvm/worker/memory/dao/MemoryMetricH2DAO.java @@ -4,6 +4,7 @@ import org.skywalking.apm.collector.core.stream.Data; import org.skywalking.apm.collector.storage.define.DataDefine; import org.skywalking.apm.collector.storage.define.jvm.MemoryMetricTable; 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 java.util.HashMap; @@ -12,13 +13,15 @@ import java.util.Map; /** * @author pengys5 */ -public class MemoryMetricH2DAO extends H2DAO implements IMemoryMetricDAO, IPersistenceDAO, Map> { +public class MemoryMetricH2DAO extends H2DAO implements IMemoryMetricDAO, IPersistenceDAO { @Override public Data get(String id, DataDefine dataDefine) { return null; } - @Override public Map prepareBatchInsert(Data data) { + @Override public H2SqlEntity prepareBatchInsert(Data data) { + H2SqlEntity entity = new H2SqlEntity(); Map source = new HashMap<>(); + source.put("id", data.getDataString(0)); source.put(MemoryMetricTable.COLUMN_APPLICATION_INSTANCE_ID, data.getDataInteger(0)); source.put(MemoryMetricTable.COLUMN_IS_HEAP, data.getDataBoolean(0)); source.put(MemoryMetricTable.COLUMN_INIT, data.getDataLong(0)); @@ -27,10 +30,13 @@ public class MemoryMetricH2DAO extends H2DAO implements IMemoryMetricDAO, IPersi source.put(MemoryMetricTable.COLUMN_COMMITTED, data.getDataLong(3)); source.put(MemoryMetricTable.COLUMN_TIME_BUCKET, data.getDataLong(4)); - return source; + String sql = getBatchInsertSql(MemoryMetricTable.TABLE, source.keySet()); + entity.setSql(sql); + entity.setParams(source.values().toArray(new Object[0])); + return entity; } - @Override public Map prepareBatchUpdate(Data data) { + @Override public H2SqlEntity prepareBatchUpdate(Data data) { return null; } } diff --git a/apm-collector/apm-collector-agentjvm/src/main/java/org/skywalking/apm/collector/agentjvm/worker/memorypool/dao/MemoryPoolMetricH2DAO.java b/apm-collector/apm-collector-agentjvm/src/main/java/org/skywalking/apm/collector/agentjvm/worker/memorypool/dao/MemoryPoolMetricH2DAO.java index 7cbd236bb..64a8638ba 100644 --- a/apm-collector/apm-collector-agentjvm/src/main/java/org/skywalking/apm/collector/agentjvm/worker/memorypool/dao/MemoryPoolMetricH2DAO.java +++ b/apm-collector/apm-collector-agentjvm/src/main/java/org/skywalking/apm/collector/agentjvm/worker/memorypool/dao/MemoryPoolMetricH2DAO.java @@ -4,6 +4,7 @@ import org.skywalking.apm.collector.core.stream.Data; import org.skywalking.apm.collector.storage.define.DataDefine; import org.skywalking.apm.collector.storage.define.jvm.MemoryPoolMetricTable; 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 java.util.HashMap; @@ -12,13 +13,15 @@ import java.util.Map; /** * @author pengys5 */ -public class MemoryPoolMetricH2DAO extends H2DAO implements IMemoryPoolMetricDAO, IPersistenceDAO, Map> { +public class MemoryPoolMetricH2DAO extends H2DAO implements IMemoryPoolMetricDAO, IPersistenceDAO { @Override public Data get(String id, DataDefine dataDefine) { return null; } - @Override public Map prepareBatchInsert(Data data) { + @Override public H2SqlEntity prepareBatchInsert(Data data) { + H2SqlEntity entity = new H2SqlEntity(); Map source = new HashMap<>(); + source.put("id", data.getDataString(0)); source.put(MemoryPoolMetricTable.COLUMN_INSTANCE_ID, data.getDataInteger(0)); source.put(MemoryPoolMetricTable.COLUMN_POOL_TYPE, data.getDataInteger(1)); source.put(MemoryPoolMetricTable.COLUMN_INIT, data.getDataLong(0)); @@ -27,10 +30,13 @@ public class MemoryPoolMetricH2DAO extends H2DAO implements IMemoryPoolMetricDAO source.put(MemoryPoolMetricTable.COLUMN_COMMITTED, data.getDataLong(3)); source.put(MemoryPoolMetricTable.COLUMN_TIME_BUCKET, data.getDataLong(4)); - return source; + String sql = getBatchInsertSql(MemoryPoolMetricTable.TABLE, source.keySet()); + entity.setSql(sql); + entity.setParams(source.values().toArray(new Object[0])); + return entity; } - @Override public Map prepareBatchUpdate(Data data) { + @Override public H2SqlEntity prepareBatchUpdate(Data data) { return null; } } 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 53337184f..6f45a62cb 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 @@ -8,12 +8,15 @@ import org.skywalking.apm.collector.storage.h2.dao.H2DAO; import org.slf4j.Logger; import org.slf4j.LoggerFactory; +import java.text.MessageFormat; + /** * @author pengys5 */ public class ApplicationH2DAO extends H2DAO implements IApplicationDAO { private final Logger logger = LoggerFactory.getLogger(ApplicationH2DAO.class); - @Override + private static final String INSERT_APPLICATION_SQL = "insert into {0}({1}, {2}) values(?, ?)"; +; @Override public int getApplicationId(String applicationCode) { logger.info("get the application id with application code = {}", applicationCode); String sql = "select " + ApplicationTable.COLUMN_APPLICATION_ID + " from " + @@ -34,12 +37,12 @@ public class ApplicationH2DAO extends H2DAO implements IApplicationDAO { @Override public void save(ApplicationDataDefine.Application application) { - String insertSQL = "insert into " + ApplicationTable.TABLE + "(" + ApplicationTable.COLUMN_APPLICATION_ID + - "," + ApplicationTable.COLUMN_APPLICATION_CODE + ") values (?, ?)"; H2Client client = getClient(); + String sql = MessageFormat.format(INSERT_APPLICATION_SQL, ApplicationTable.TABLE, ApplicationTable.COLUMN_APPLICATION_ID, + ApplicationTable.COLUMN_APPLICATION_CODE); Object[] params = new Object[] {application.getApplicationId(), application.getApplicationCode()}; try { - client.execute(insertSQL, params); + client.execute(sql, params); } catch (H2ClientException e) { logger.error(e.getMessage(), e); } 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 c11920a7a..6b7ccc612 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,33 +1,97 @@ package org.skywalking.apm.collector.agentregister.worker.instance.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.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 */ public class InstanceH2DAO extends H2DAO implements IInstanceDAO { + private final Logger logger = LoggerFactory.getLogger(InstanceH2DAO.class); + private static final String GET_INSTANCE_ID_SQL = "select {0} from {1} where {2} = ? and {3} = ?"; + private static final String GET_APPLICATION_ID_SQL = "select {0} from {1} where {2} = ?"; + private static final String UPDATE_HEARTBEAT_TIME_SQL = "updatte {0} set {1} = ? where {2} = ?"; @Override public int getInstanceId(int applicationId, String agentUUID) { + logger.info("get the application id with application id = {}, agentUUID = {}", applicationId, agentUUID); + H2Client client = getClient(); + String sql = MessageFormat.format(GET_INSTANCE_ID_SQL, InstanceTable.COLUMN_INSTANCE_ID, InstanceTable.TABLE, InstanceTable.COLUMN_APPLICATION_ID, + InstanceTable.COLUMN_AGENT_UUID); + Object[] params = new Object[]{applicationId, agentUUID}; + try (ResultSet rs = client.executeQuery(sql, params)) { + if (rs.next()) { + return rs.getInt(InstanceTable.COLUMN_INSTANCE_ID); + } + } catch (SQLException | H2ClientException e) { + logger.error(e.getMessage(), e); + } return 0; } @Override public int getMaxInstanceId() { - return 0; + return getMaxId(InstanceTable.TABLE, InstanceTable.COLUMN_INSTANCE_ID); } @Override public int getMinInstanceId() { - return 0; + return getMinId(InstanceTable.TABLE, InstanceTable.COLUMN_INSTANCE_ID); } @Override public void save(InstanceDataDefine.Instance instance) { - + H2Client client = getClient(); + Map source = new HashMap<>(); + source.put(InstanceTable.COLUMN_INSTANCE_ID, instance.getInstanceId()); + source.put(InstanceTable.COLUMN_APPLICATION_ID, instance.getApplicationId()); + source.put(InstanceTable.COLUMN_AGENT_UUID, instance.getAgentUUID()); + source.put(InstanceTable.COLUMN_REGISTER_TIME, instance.getRegisterTime()); + source.put(InstanceTable.COLUMN_HEARTBEAT_TIME, instance.getHeartBeatTime()); + source.put(InstanceTable.COLUMN_OS_INFO, instance.getOsInfo()); + String sql = getBatchInsertSql(InstanceTable.TABLE, source.keySet()); + Object[] params = source.values().toArray(new Object[0]); + try { + client.execute(sql, params); + } catch (H2ClientException e) { + logger.error(e.getMessage(), e); + } } @Override public void updateHeartbeatTime(int instanceId, long heartbeatTime) { - + H2Client client = getClient(); + String sql = MessageFormat.format(UPDATE_HEARTBEAT_TIME_SQL, InstanceTable.TABLE, InstanceTable.COLUMN_HEARTBEAT_TIME, + InstanceTable.COLUMN_INSTANCE_ID); + Object[] params = new Object[] {heartbeatTime, instanceId}; + try { + client.execute(sql, params); + } catch (H2ClientException e) { + logger.error(e.getMessage(), e); + } } @Override public int getApplicationId(int applicationInstanceId) { + logger.info("get the application id with application id = {}", applicationInstanceId); + H2Client client = getClient(); + String sql = MessageFormat.format(GET_APPLICATION_ID_SQL, InstanceTable.COLUMN_APPLICATION_ID, InstanceTable.TABLE, InstanceTable.COLUMN_APPLICATION_ID); + Object[] params = new Object[]{applicationInstanceId}; + try (ResultSet rs = client.executeQuery(sql, params)) { + if (rs.next()) { + return rs.getInt(InstanceTable.COLUMN_APPLICATION_ID); + } + } catch (SQLException | H2ClientException e) { + logger.error(e.getMessage(), e); + } return 0; } } diff --git a/apm-collector/apm-collector-agentstream/src/main/java/org/skywalking/apm/collector/agentstream/worker/global/dao/GlobalTraceH2DAO.java b/apm-collector/apm-collector-agentstream/src/main/java/org/skywalking/apm/collector/agentstream/worker/global/dao/GlobalTraceH2DAO.java index d17002aa0..05dee62ab 100644 --- a/apm-collector/apm-collector-agentstream/src/main/java/org/skywalking/apm/collector/agentstream/worker/global/dao/GlobalTraceH2DAO.java +++ b/apm-collector/apm-collector-agentstream/src/main/java/org/skywalking/apm/collector/agentstream/worker/global/dao/GlobalTraceH2DAO.java @@ -1,27 +1,44 @@ package org.skywalking.apm.collector.agentstream.worker.global.dao; -import org.skywalking.apm.collector.agentstream.worker.instance.performance.dao.InstPerformanceH2DAO; +import org.skywalking.apm.collector.core.framework.UnexpectedException; import org.skywalking.apm.collector.core.stream.Data; import org.skywalking.apm.collector.storage.define.DataDefine; +import org.skywalking.apm.collector.storage.define.global.GlobalTraceTable; +import org.skywalking.apm.collector.storage.define.node.NodeComponentTable; 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.util.HashMap; import java.util.Map; /** * @author pengys5 */ -public class GlobalTraceH2DAO extends H2DAO implements IGlobalTraceDAO, IPersistenceDAO, Map> { +public class GlobalTraceH2DAO extends H2DAO implements IGlobalTraceDAO, IPersistenceDAO { private final Logger logger = LoggerFactory.getLogger(GlobalTraceH2DAO.class); @Override public Data get(String id, DataDefine dataDefine) { - return null; + throw new UnexpectedException("There is no need to merge stream data with database data."); } - @Override public Map prepareBatchInsert(Data data) { - return null; + + @Override public H2SqlEntity prepareBatchUpdate(Data data) { + throw new UnexpectedException("There is no need to merge stream data with database data."); } - @Override public Map prepareBatchUpdate(Data data) { - return null; + + @Override public H2SqlEntity prepareBatchInsert(Data data) { + Map source = new HashMap<>(); + H2SqlEntity entity = new H2SqlEntity(); + source.put("id", data.getDataString(0)); + source.put(GlobalTraceTable.COLUMN_SEGMENT_ID, data.getDataString(1)); + source.put(GlobalTraceTable.COLUMN_GLOBAL_TRACE_ID, data.getDataString(2)); + source.put(GlobalTraceTable.COLUMN_TIME_BUCKET, data.getDataLong(0)); + logger.debug("global trace source: {}", source.toString()); + + String sql = getBatchInsertSql(NodeComponentTable.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/instance/performance/dao/InstPerformanceH2DAO.java b/apm-collector/apm-collector-agentstream/src/main/java/org/skywalking/apm/collector/agentstream/worker/instance/performance/dao/InstPerformanceH2DAO.java index bb7b9fb04..418191320 100644 --- a/apm-collector/apm-collector-agentstream/src/main/java/org/skywalking/apm/collector/agentstream/worker/instance/performance/dao/InstPerformanceH2DAO.java +++ b/apm-collector/apm-collector-agentstream/src/main/java/org/skywalking/apm/collector/agentstream/worker/instance/performance/dao/InstPerformanceH2DAO.java @@ -1,27 +1,74 @@ package org.skywalking.apm.collector.agentstream.worker.instance.performance.dao; -import org.skywalking.apm.collector.agentstream.worker.node.component.dao.NodeComponentH2DAO; +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.instance.InstPerformanceTable; 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.util.Map; +import java.sql.ResultSet; +import java.sql.SQLException; +import java.text.MessageFormat; +import java.util.*; /** * @author pengys5 */ -public class InstPerformanceH2DAO extends H2DAO implements IInstPerformanceDAO, IPersistenceDAO, Map> { +public class InstPerformanceH2DAO extends H2DAO implements IInstPerformanceDAO, IPersistenceDAO { private final Logger logger = LoggerFactory.getLogger(InstPerformanceH2DAO.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, InstPerformanceTable.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(InstPerformanceTable.COLUMN_APPLICATION_ID)); + data.setDataInteger(1, rs.getInt(InstPerformanceTable.COLUMN_INSTANCE_ID)); + data.setDataInteger(2, rs.getInt(InstPerformanceTable.COLUMN_CALLS)); + data.setDataLong(0, rs.getLong(InstPerformanceTable.COLUMN_COST_TOTAL)); + data.setDataLong(1, rs.getLong(InstPerformanceTable.COLUMN_TIME_BUCKET)); + return data; + } + } catch (SQLException | H2ClientException e) { + logger.error(e.getMessage(), e); + } return null; } - @Override public Map prepareBatchInsert(Data data) { - return null; + @Override public H2SqlEntity prepareBatchInsert(Data data) { + Map source = new HashMap<>(); + H2SqlEntity entity = new H2SqlEntity(); + source.put("id", data.getDataString(0)); + source.put(InstPerformanceTable.COLUMN_APPLICATION_ID, data.getDataInteger(0)); + source.put(InstPerformanceTable.COLUMN_INSTANCE_ID, data.getDataInteger(1)); + source.put(InstPerformanceTable.COLUMN_CALLS, data.getDataInteger(2)); + source.put(InstPerformanceTable.COLUMN_COST_TOTAL, data.getDataLong(0)); + source.put(InstPerformanceTable.COLUMN_TIME_BUCKET, data.getDataLong(1)); + String sql = getBatchInsertSql(InstPerformanceTable.TABLE, source.keySet()); + entity.setSql(sql); + entity.setParams(source.values().toArray(new Object[0])); + return entity; } - @Override public Map prepareBatchUpdate(Data data) { - return null; + @Override public H2SqlEntity prepareBatchUpdate(Data data) { + Map source = new HashMap<>(); + H2SqlEntity entity = new H2SqlEntity(); + source.put(InstPerformanceTable.COLUMN_APPLICATION_ID, data.getDataInteger(0)); + source.put(InstPerformanceTable.COLUMN_INSTANCE_ID, data.getDataInteger(1)); + source.put(InstPerformanceTable.COLUMN_CALLS, data.getDataInteger(2)); + source.put(InstPerformanceTable.COLUMN_COST_TOTAL, data.getDataLong(0)); + source.put(InstPerformanceTable.COLUMN_TIME_BUCKET, data.getDataLong(1)); + String id = data.getDataString(0); + String sql = getBatchUpdateSql(InstPerformanceTable.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/node/component/dao/NodeComponentH2DAO.java b/apm-collector/apm-collector-agentstream/src/main/java/org/skywalking/apm/collector/agentstream/worker/node/component/dao/NodeComponentH2DAO.java index 870f656e6..98f0797f7 100644 --- a/apm-collector/apm-collector-agentstream/src/main/java/org/skywalking/apm/collector/agentstream/worker/node/component/dao/NodeComponentH2DAO.java +++ b/apm-collector/apm-collector-agentstream/src/main/java/org/skywalking/apm/collector/agentstream/worker/node/component/dao/NodeComponentH2DAO.java @@ -1,26 +1,82 @@ package org.skywalking.apm.collector.agentstream.worker.node.component.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.NodeComponentTable; +import org.skywalking.apm.collector.storage.define.serviceref.ServiceReferenceTable; 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.util.Map; +import java.sql.ResultSet; +import java.sql.SQLException; +import java.text.MessageFormat; +import java.util.*; /** * @author pengys5 */ -public class NodeComponentH2DAO extends H2DAO implements INodeComponentDAO, IPersistenceDAO, Map> { +public class NodeComponentH2DAO extends H2DAO implements INodeComponentDAO, IPersistenceDAO { private final Logger logger = LoggerFactory.getLogger(NodeComponentH2DAO.class); - @Override public Data get(String id, DataDefine dataDefine) { + 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, ServiceReferenceTable.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(NodeComponentTable.COLUMN_COMPONENT_ID)); + data.setDataString(1, rs.getString(NodeComponentTable.COLUMN_COMPONENT_NAME)); + data.setDataInteger(1, rs.getInt(NodeComponentTable.COLUMN_PEER_ID)); + data.setDataString(2, rs.getString(NodeComponentTable.COLUMN_PEER)); + data.setDataLong(0, rs.getLong(NodeComponentTable.COLUMN_TIME_BUCKET)); + return data; + } + } catch (SQLException | H2ClientException e) { + logger.error(e.getMessage(), e); + } return null; } - @Override public Map prepareBatchInsert(Data data) { - return null; + + @Override + public H2SqlEntity prepareBatchInsert(Data data) { + Map source = new HashMap<>(); + H2SqlEntity entity = new H2SqlEntity(); + source.put("id", data.getDataString(0)); + source.put(NodeComponentTable.COLUMN_COMPONENT_ID, data.getDataInteger(0)); + source.put(NodeComponentTable.COLUMN_COMPONENT_NAME, data.getDataString(1)); + source.put(NodeComponentTable.COLUMN_PEER_ID, data.getDataInteger(1)); + source.put(NodeComponentTable.COLUMN_PEER, data.getDataString(2)); + source.put(NodeComponentTable.COLUMN_TIME_BUCKET, data.getDataLong(0)); + + String sql = getBatchInsertSql(NodeComponentTable.TABLE, source.keySet()); + entity.setSql(sql); + entity.setParams(source.values().toArray(new Object[0])); + return entity; } - @Override public Map prepareBatchUpdate(Data data) { - return null; + + @Override + public H2SqlEntity prepareBatchUpdate(Data data) { + Map source = new HashMap<>(); + H2SqlEntity entity = new H2SqlEntity(); + source.put(NodeComponentTable.COLUMN_COMPONENT_ID, data.getDataInteger(0)); + source.put(NodeComponentTable.COLUMN_COMPONENT_NAME, data.getDataString(1)); + source.put(NodeComponentTable.COLUMN_PEER_ID, data.getDataInteger(1)); + source.put(NodeComponentTable.COLUMN_PEER, data.getDataString(2)); + source.put(NodeComponentTable.COLUMN_TIME_BUCKET, data.getDataLong(0)); + String id = data.getDataString(0); + String sql = getBatchUpdateSql(NodeComponentTable.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/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 e5cb8709a..2f8712c3d 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 @@ -1,27 +1,72 @@ package org.skywalking.apm.collector.agentstream.worker.node.mapping.dao; import org.skywalking.apm.collector.agentstream.worker.node.component.dao.NodeComponentH2DAO; +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.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.util.Map; +import java.sql.ResultSet; +import java.sql.SQLException; +import java.text.MessageFormat; +import java.util.*; /** * @author pengys5 */ -public class NodeMappingH2DAO extends H2DAO implements INodeMappingDAO, IPersistenceDAO, Map> { +public class NodeMappingH2DAO extends H2DAO implements INodeMappingDAO, IPersistenceDAO { private final Logger logger = LoggerFactory.getLogger(NodeComponentH2DAO.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, NodeMappingTable.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(NodeMappingTable.COLUMN_APPLICATION_ID)); + data.setDataInteger(1, rs.getInt(NodeMappingTable.COLUMN_ADDRESS_ID)); + data.setDataString(1, rs.getString(NodeMappingTable.COLUMN_ADDRESS)); + data.setDataLong(0, rs.getLong(NodeMappingTable.COLUMN_TIME_BUCKET)); + return data; + } + } catch (SQLException | H2ClientException e) { + logger.error(e.getMessage(), e); + } return null; } - @Override public Map prepareBatchInsert(Data data) { - return null; + @Override public H2SqlEntity prepareBatchInsert(Data data) { + Map source = new HashMap<>(); + H2SqlEntity entity = new H2SqlEntity(); + source.put("id", data.getDataString(0)); + source.put(NodeMappingTable.COLUMN_APPLICATION_ID, data.getDataInteger(0)); + source.put(NodeMappingTable.COLUMN_ADDRESS_ID, data.getDataInteger(1)); + source.put(NodeMappingTable.COLUMN_ADDRESS, data.getDataString(1)); + 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; } - @Override public Map prepareBatchUpdate(Data data) { - return null; + @Override public H2SqlEntity prepareBatchUpdate(Data data) { + Map source = new HashMap<>(); + H2SqlEntity entity = new H2SqlEntity(); + source.put(NodeMappingTable.COLUMN_APPLICATION_ID, data.getDataInteger(0)); + source.put(NodeMappingTable.COLUMN_ADDRESS_ID, data.getDataInteger(1)); + source.put(NodeMappingTable.COLUMN_ADDRESS, data.getDataString(1)); + source.put(NodeMappingTable.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/dao/NodeReferenceH2DAO.java b/apm-collector/apm-collector-agentstream/src/main/java/org/skywalking/apm/collector/agentstream/worker/noderef/dao/NodeReferenceH2DAO.java index 7fe20ff63..f03932c9f 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,27 +1,25 @@ package org.skywalking.apm.collector.agentstream.worker.noderef.dao; -import org.skywalking.apm.collector.agentstream.worker.segment.cost.dao.SegmentCostH2DAO; import org.skywalking.apm.collector.core.stream.Data; import org.skywalking.apm.collector.storage.define.DataDefine; 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.util.Map; - /** * @author pengys5 */ -public class NodeReferenceH2DAO extends H2DAO implements INodeReferenceDAO, IPersistenceDAO, Map> { +public class NodeReferenceH2DAO extends H2DAO implements INodeReferenceDAO, IPersistenceDAO { private final Logger logger = LoggerFactory.getLogger(NodeReferenceH2DAO.class); @Override public Data get(String id, DataDefine dataDefine) { return null; } - @Override public Map prepareBatchInsert(Data data) { + @Override public H2SqlEntity prepareBatchInsert(Data data) { return null; } - @Override public Map prepareBatchUpdate(Data data) { + @Override public H2SqlEntity prepareBatchUpdate(Data data) { return null; } } diff --git a/apm-collector/apm-collector-agentstream/src/main/java/org/skywalking/apm/collector/agentstream/worker/segment/cost/dao/SegmentCostH2DAO.java b/apm-collector/apm-collector-agentstream/src/main/java/org/skywalking/apm/collector/agentstream/worker/segment/cost/dao/SegmentCostH2DAO.java index 1fb2e7181..77f9f2628 100644 --- a/apm-collector/apm-collector-agentstream/src/main/java/org/skywalking/apm/collector/agentstream/worker/segment/cost/dao/SegmentCostH2DAO.java +++ b/apm-collector/apm-collector-agentstream/src/main/java/org/skywalking/apm/collector/agentstream/worker/segment/cost/dao/SegmentCostH2DAO.java @@ -1,34 +1,46 @@ package org.skywalking.apm.collector.agentstream.worker.segment.cost.dao; -import org.skywalking.apm.collector.agentstream.worker.service.entry.dao.ServiceEntryH2DAO; -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.service.ServiceEntryTable; -import org.skywalking.apm.collector.storage.define.serviceref.ServiceReferenceTable; +import org.skywalking.apm.collector.storage.define.segment.SegmentCostTable; 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.util.HashMap; import java.util.Map; /** * @author pengys5 */ -public class SegmentCostH2DAO extends H2DAO implements ISegmentCostDAO, IPersistenceDAO, Map> { +public class SegmentCostH2DAO extends H2DAO implements ISegmentCostDAO, IPersistenceDAO { private final Logger logger = LoggerFactory.getLogger(SegmentCostH2DAO.class); @Override public Data get(String id, DataDefine dataDefine) { return null; } - @Override public Map prepareBatchInsert(Data data) { - return null; + @Override public H2SqlEntity prepareBatchInsert(Data data) { + logger.debug("segment cost prepareBatchInsert, id: {}", data.getDataString(0)); + H2SqlEntity entity = new H2SqlEntity(); + Map source = new HashMap<>(); + source.put("id", data.getDataString(0)); + source.put(SegmentCostTable.COLUMN_SEGMENT_ID, data.getDataString(1)); + source.put(SegmentCostTable.COLUMN_APPLICATION_ID, data.getDataInteger(0)); + source.put(SegmentCostTable.COLUMN_SERVICE_NAME, data.getDataString(2)); + source.put(SegmentCostTable.COLUMN_COST, data.getDataLong(0)); + source.put(SegmentCostTable.COLUMN_START_TIME, data.getDataLong(1)); + source.put(SegmentCostTable.COLUMN_END_TIME, data.getDataLong(2)); + source.put(SegmentCostTable.COLUMN_IS_ERROR, data.getDataBoolean(0)); + source.put(SegmentCostTable.COLUMN_TIME_BUCKET, data.getDataLong(3)); + logger.debug("segment cost source: {}", source.toString()); + + String sql = getBatchInsertSql(SegmentCostTable.TABLE, source.keySet()); + entity.setSql(sql); + entity.setParams(source.values().toArray(new Object[0])); + return entity; } - @Override public Map prepareBatchUpdate(Data data) { + @Override public H2SqlEntity prepareBatchUpdate(Data data) { return null; } } diff --git a/apm-collector/apm-collector-agentstream/src/main/java/org/skywalking/apm/collector/agentstream/worker/segment/origin/dao/SegmentH2DAO.java b/apm-collector/apm-collector-agentstream/src/main/java/org/skywalking/apm/collector/agentstream/worker/segment/origin/dao/SegmentH2DAO.java index 37054c67b..1d78a8434 100644 --- a/apm-collector/apm-collector-agentstream/src/main/java/org/skywalking/apm/collector/agentstream/worker/segment/origin/dao/SegmentH2DAO.java +++ b/apm-collector/apm-collector-agentstream/src/main/java/org/skywalking/apm/collector/agentstream/worker/segment/origin/dao/SegmentH2DAO.java @@ -3,25 +3,38 @@ package org.skywalking.apm.collector.agentstream.worker.segment.origin.dao; import org.skywalking.apm.collector.agentstream.worker.segment.cost.dao.SegmentCostH2DAO; import org.skywalking.apm.collector.core.stream.Data; import org.skywalking.apm.collector.storage.define.DataDefine; +import org.skywalking.apm.collector.storage.define.segment.SegmentTable; 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.util.Base64; +import java.util.HashMap; import java.util.Map; /** * @author pengys5 */ -public class SegmentH2DAO extends H2DAO implements ISegmentDAO, IPersistenceDAO, Map> { +public class SegmentH2DAO extends H2DAO implements ISegmentDAO, IPersistenceDAO { private final Logger logger = LoggerFactory.getLogger(SegmentCostH2DAO.class); @Override public Data get(String id, DataDefine dataDefine) { return null; } - @Override public Map prepareBatchInsert(Data data) { - return null; + @Override public H2SqlEntity prepareBatchInsert(Data data) { + Map source = new HashMap<>(); + H2SqlEntity entity = new H2SqlEntity(); + source.put("id", data.getDataString(0)); + source.put(SegmentTable.COLUMN_DATA_BINARY, new String(Base64.getEncoder().encode(data.getDataBytes(0)))); + logger.debug("segment source: {}", source.toString()); + + String sql = getBatchInsertSql(SegmentTable.TABLE, source.keySet()); + entity.setSql(sql); + entity.setParams(source.values().toArray(new Object[0])); + return entity; } - @Override public Map prepareBatchUpdate(Data data) { + @Override public H2SqlEntity prepareBatchUpdate(Data data) { return null; } } diff --git a/apm-collector/apm-collector-agentstream/src/main/java/org/skywalking/apm/collector/agentstream/worker/service/entry/dao/ServiceEntryH2DAO.java b/apm-collector/apm-collector-agentstream/src/main/java/org/skywalking/apm/collector/agentstream/worker/service/entry/dao/ServiceEntryH2DAO.java index a2650151b..aa182958e 100644 --- a/apm-collector/apm-collector-agentstream/src/main/java/org/skywalking/apm/collector/agentstream/worker/service/entry/dao/ServiceEntryH2DAO.java +++ b/apm-collector/apm-collector-agentstream/src/main/java/org/skywalking/apm/collector/agentstream/worker/service/entry/dao/ServiceEntryH2DAO.java @@ -1,6 +1,5 @@ package org.skywalking.apm.collector.agentstream.worker.service.entry.dao; -import org.skywalking.apm.collector.agentstream.worker.serviceref.dao.ServiceReferenceH2DAO; import org.skywalking.apm.collector.client.h2.H2Client; import org.skywalking.apm.collector.client.h2.H2ClientException; import org.skywalking.apm.collector.core.stream.Data; @@ -8,27 +7,25 @@ import org.skywalking.apm.collector.storage.define.DataDefine; import org.skywalking.apm.collector.storage.define.service.ServiceEntryTable; import org.skywalking.apm.collector.storage.define.serviceref.ServiceReferenceTable; 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.util.HashMap; -import java.util.Map; +import java.util.*; /** * @author pengys5 */ -public class ServiceEntryH2DAO extends H2DAO implements IServiceEntryDAO, IPersistenceDAO, Map> { +public class ServiceEntryH2DAO extends H2DAO implements IServiceEntryDAO, IPersistenceDAO { private final Logger logger = LoggerFactory.getLogger(ServiceEntryH2DAO.class); @Override public Data get(String id, DataDefine dataDefine) { H2Client client = getClient(); - String sql = "select * from " + ServiceReferenceTable.TABLE + " where " + ServiceReferenceTable.COLUMN_ENTRY_SERVICE_ID + "=?"; + String sql = "select * from " + ServiceReferenceTable.TABLE + " where id = ?"; Object[] params = new Object[] {id}; - ResultSet rs = null; - try { - rs = client.executeQuery(sql, params); + try (ResultSet rs = client.executeQuery(sql, params)) { Data data = dataDefine.build(id); data.setDataInteger(0, rs.getInt(ServiceEntryTable.COLUMN_APPLICATION_ID)); data.setDataInteger(1, rs.getInt(ServiceEntryTable.COLUMN_ENTRY_SERVICE_ID)); @@ -38,27 +35,37 @@ public class ServiceEntryH2DAO extends H2DAO implements IServiceEntryDAO, IPersi return data; } catch (SQLException | H2ClientException e) { logger.error(e.getMessage(), e); - } finally { - client.closeResultSet(rs); } return null; } - @Override public Map prepareBatchInsert(Data data) { + @Override public H2SqlEntity prepareBatchInsert(Data data) { + H2SqlEntity entity = new H2SqlEntity(); Map source = new HashMap<>(); + source.put("id", data.getDataString(0)); source.put(ServiceEntryTable.COLUMN_APPLICATION_ID, data.getDataInteger(0)); source.put(ServiceEntryTable.COLUMN_ENTRY_SERVICE_ID, data.getDataInteger(1)); source.put(ServiceEntryTable.COLUMN_ENTRY_SERVICE_NAME, data.getDataString(1)); source.put(ServiceEntryTable.COLUMN_REGISTER_TIME, data.getDataLong(0)); source.put(ServiceEntryTable.COLUMN_NEWEST_TIME, data.getDataLong(1)); - return source; + String sql = getBatchInsertSql(ServiceEntryTable.TABLE, source.keySet()); + entity.setSql(sql); + entity.setParams(source.values().toArray(new Object[0])); + return entity; } - @Override public Map prepareBatchUpdate(Data data) { + @Override public H2SqlEntity prepareBatchUpdate(Data data) { + H2SqlEntity entity = new H2SqlEntity(); Map source = new HashMap<>(); source.put(ServiceEntryTable.COLUMN_APPLICATION_ID, data.getDataInteger(0)); source.put(ServiceEntryTable.COLUMN_ENTRY_SERVICE_ID, data.getDataInteger(1)); source.put(ServiceEntryTable.COLUMN_ENTRY_SERVICE_NAME, data.getDataString(1)); source.put(ServiceEntryTable.COLUMN_REGISTER_TIME, data.getDataLong(0)); source.put(ServiceEntryTable.COLUMN_NEWEST_TIME, data.getDataLong(1)); - return source; + String id = data.getDataString(0); + String sql = getBatchUpdateSql(ServiceEntryTable.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/serviceref/dao/ServiceReferenceH2DAO.java b/apm-collector/apm-collector-agentstream/src/main/java/org/skywalking/apm/collector/agentstream/worker/serviceref/dao/ServiceReferenceH2DAO.java index 6b17bf8ec..5cf648dea 100644 --- a/apm-collector/apm-collector-agentstream/src/main/java/org/skywalking/apm/collector/agentstream/worker/serviceref/dao/ServiceReferenceH2DAO.java +++ b/apm-collector/apm-collector-agentstream/src/main/java/org/skywalking/apm/collector/agentstream/worker/serviceref/dao/ServiceReferenceH2DAO.java @@ -2,9 +2,9 @@ package org.skywalking.apm.collector.agentstream.worker.serviceref.dao; import org.skywalking.apm.collector.client.h2.H2Client; import org.skywalking.apm.collector.client.h2.H2ClientException; -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.skywalking.apm.collector.storage.h2.define.H2SqlEntity; import org.skywalking.apm.collector.stream.worker.impl.dao.IPersistenceDAO; import org.skywalking.apm.collector.core.stream.Data; import org.skywalking.apm.collector.storage.define.DataDefine; @@ -13,47 +13,50 @@ import org.slf4j.LoggerFactory; import java.sql.ResultSet; import java.sql.SQLException; -import java.util.HashMap; -import java.util.Map; +import java.text.MessageFormat; +import java.util.*; /** * @author pengys5 */ -public class ServiceReferenceH2DAO extends H2DAO implements IServiceReferenceDAO, IPersistenceDAO, Map> { +public class ServiceReferenceH2DAO extends H2DAO implements IServiceReferenceDAO, IPersistenceDAO { private final Logger logger = LoggerFactory.getLogger(ServiceReferenceH2DAO.class); - @Override public Data get(String id, DataDefine dataDefine) { + private static final String GET_SQL = "select * from {0} where {1} = ?"; + @Override + public Data get(String id, DataDefine dataDefine) { H2Client client = getClient(); - String sql = "select * from " + ServiceReferenceTable.TABLE + " where " + ServiceReferenceTable.COLUMN_ENTRY_SERVICE_ID + "=?"; - Object[] params = new Object[] {id}; - ResultSet rs = null; - try { - rs = client.executeQuery(sql, params); - Data data = dataDefine.build(id); - data.setDataInteger(0, rs.getInt(ServiceReferenceTable.COLUMN_ENTRY_SERVICE_ID)); - data.setDataString(1, rs.getString(ServiceReferenceTable.COLUMN_ENTRY_SERVICE_NAME)); - data.setDataInteger(1, rs.getInt(ServiceReferenceTable.COLUMN_FRONT_SERVICE_ID)); - data.setDataString(2, rs.getString(ServiceReferenceTable.COLUMN_FRONT_SERVICE_NAME)); - data.setDataInteger(2, rs.getInt(ServiceReferenceTable.COLUMN_BEHIND_SERVICE_ID)); - data.setDataString(3, rs.getString(ServiceReferenceTable.COLUMN_BEHIND_SERVICE_NAME)); - data.setDataLong(0, rs.getLong(ServiceReferenceTable.COLUMN_S1_LTE)); - data.setDataLong(1, rs.getLong(ServiceReferenceTable.COLUMN_S3_LTE)); - data.setDataLong(2, rs.getLong(ServiceReferenceTable.COLUMN_S5_LTE)); - data.setDataLong(3, rs.getLong(ServiceReferenceTable.COLUMN_S5_GT)); - data.setDataLong(4, rs.getLong(ServiceReferenceTable.COLUMN_SUMMARY)); - data.setDataLong(5, rs.getLong(ServiceReferenceTable.COLUMN_ERROR)); - data.setDataLong(6, rs.getLong(ServiceReferenceTable.COLUMN_COST_SUMMARY)); - data.setDataLong(7, rs.getLong(ServiceReferenceTable.COLUMN_TIME_BUCKET)); - return data; + String sql = MessageFormat.format(GET_SQL, ServiceReferenceTable.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(ServiceReferenceTable.COLUMN_ENTRY_SERVICE_ID)); + data.setDataString(1, rs.getString(ServiceReferenceTable.COLUMN_ENTRY_SERVICE_NAME)); + data.setDataInteger(1, rs.getInt(ServiceReferenceTable.COLUMN_FRONT_SERVICE_ID)); + data.setDataString(2, rs.getString(ServiceReferenceTable.COLUMN_FRONT_SERVICE_NAME)); + data.setDataInteger(2, rs.getInt(ServiceReferenceTable.COLUMN_BEHIND_SERVICE_ID)); + data.setDataString(3, rs.getString(ServiceReferenceTable.COLUMN_BEHIND_SERVICE_NAME)); + data.setDataLong(0, rs.getLong(ServiceReferenceTable.COLUMN_S1_LTE)); + data.setDataLong(1, rs.getLong(ServiceReferenceTable.COLUMN_S3_LTE)); + data.setDataLong(2, rs.getLong(ServiceReferenceTable.COLUMN_S5_LTE)); + data.setDataLong(3, rs.getLong(ServiceReferenceTable.COLUMN_S5_GT)); + data.setDataLong(4, rs.getLong(ServiceReferenceTable.COLUMN_SUMMARY)); + data.setDataLong(5, rs.getLong(ServiceReferenceTable.COLUMN_ERROR)); + data.setDataLong(6, rs.getLong(ServiceReferenceTable.COLUMN_COST_SUMMARY)); + data.setDataLong(7, rs.getLong(ServiceReferenceTable.COLUMN_TIME_BUCKET)); + return data; + } } catch (SQLException | H2ClientException e) { logger.error(e.getMessage(), e); - } finally { - client.closeResultSet(rs); } return null; } - @Override public Map prepareBatchInsert(Data data) { + @Override + public H2SqlEntity prepareBatchInsert(Data data) { + H2SqlEntity entity = new H2SqlEntity(); Map source = new HashMap<>(); + source.put("id", data.getDataString(0)); source.put(ServiceReferenceTable.COLUMN_ENTRY_SERVICE_ID, data.getDataInteger(0)); source.put(ServiceReferenceTable.COLUMN_ENTRY_SERVICE_NAME, data.getDataString(1)); source.put(ServiceReferenceTable.COLUMN_FRONT_SERVICE_ID, data.getDataInteger(1)); @@ -69,10 +72,15 @@ public class ServiceReferenceH2DAO extends H2DAO implements IServiceReferenceDAO source.put(ServiceReferenceTable.COLUMN_COST_SUMMARY, data.getDataLong(6)); source.put(ServiceReferenceTable.COLUMN_TIME_BUCKET, data.getDataLong(7)); - return source; + String sql = getBatchInsertSql(ServiceReferenceTable.TABLE, source.keySet()); + entity.setSql(sql); + entity.setParams(source.values().toArray(new Object[0])); + return entity; } - @Override public Map prepareBatchUpdate(Data data) { + @Override + public H2SqlEntity prepareBatchUpdate(Data data) { + H2SqlEntity entity = new H2SqlEntity(); Map source = new HashMap<>(); source.put(ServiceReferenceTable.COLUMN_ENTRY_SERVICE_ID, data.getDataInteger(0)); source.put(ServiceReferenceTable.COLUMN_ENTRY_SERVICE_NAME, data.getDataString(1)); @@ -89,6 +97,12 @@ public class ServiceReferenceH2DAO extends H2DAO implements IServiceReferenceDAO source.put(ServiceReferenceTable.COLUMN_COST_SUMMARY, data.getDataLong(6)); source.put(ServiceReferenceTable.COLUMN_TIME_BUCKET, data.getDataLong(7)); - return source; + String id = data.getDataString(0); + String sql = getBatchUpdateSql(ServiceReferenceTable.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-boot/src/main/resources/application.yml b/apm-collector/apm-collector-boot/src/main/resources/application.yml index e8a4837c7..dd9eefa56 100644 --- a/apm-collector/apm-collector-boot/src/main/resources/application.yml +++ b/apm-collector/apm-collector-boot/src/main/resources/application.yml @@ -4,20 +4,20 @@ cluster: sessionTimeout: 100000 agent_server: jetty: - host: 0.0.0.0 + host: 127.0.0.1 port: 10800 context_path: / agent_stream: grpc: - host: 192.168.10.13 + host: 127.0.0.1 port: 11800 jetty: - host: 0.0.0.0 + host: 127.0.0.1 port: 12800 context_path: / ui: jetty: - host: 0.0.0.0 + host: 127.0.0.1 port: 12800 context_path: / collector_inside: diff --git a/apm-collector/apm-collector-client/src/main/java/org/skywalking/apm/collector/client/h2/H2Client.java b/apm-collector/apm-collector-client/src/main/java/org/skywalking/apm/collector/client/h2/H2Client.java index 035383716..fb62a1b1b 100644 --- a/apm-collector/apm-collector-client/src/main/java/org/skywalking/apm/collector/client/h2/H2Client.java +++ b/apm-collector/apm-collector-client/src/main/java/org/skywalking/apm/collector/client/h2/H2Client.java @@ -55,9 +55,7 @@ public class H2Client implements Client { } public void execute(String sql) throws H2ClientException { - Statement statement = null; - try { - statement = getConnection().createStatement(); + try (Statement statement = getConnection().createStatement()) { statement.execute(sql); statement.closeOnCompletion(); } catch (SQLException e) { @@ -67,13 +65,13 @@ public class H2Client implements Client { public ResultSet executeQuery(String sql, Object[] params) throws H2ClientException { logger.info("execute query with result: {}", sql); - PreparedStatement statement; ResultSet rs; + PreparedStatement statement; try { statement = getConnection().prepareStatement(sql); if (params != null) { for (int i = 0; i < params.length; i++) { - statement.setObject(i+1, params[i]); + statement.setObject(i + 1, params[i]); } } rs = statement.executeQuery(); @@ -86,30 +84,20 @@ public class H2Client implements Client { public boolean execute(String sql, Object[] params) throws H2ClientException { logger.info("execute insert/update/delete: {}", sql); - PreparedStatement statement; boolean flag; - try { - statement = getConnection().prepareStatement(sql); + Connection conn = getConnection(); + try (PreparedStatement statement = conn.prepareStatement(sql)) { + conn.setAutoCommit(false); if (params != null) { for (int i = 0; i < params.length; i++) { - statement.setObject(i+1, params[i]); + statement.setObject(i + 1, params[i]); } } flag = statement.execute(); - statement.closeOnCompletion(); + conn.commit(); } catch (SQLException e) { throw new H2ClientException(e.getMessage(), e); } return flag; } - - public void closeResultSet(ResultSet rs) { - if (rs != null) { - try { - rs.close(); - } catch (SQLException e) { - logger.error(e.getMessage(), e); - } - } - } } diff --git a/apm-collector/apm-collector-storage/src/main/java/org/skywalking/apm/collector/storage/h2/dao/BatchH2DAO.java b/apm-collector/apm-collector-storage/src/main/java/org/skywalking/apm/collector/storage/h2/dao/BatchH2DAO.java index 27b69f6d4..397f13bbb 100644 --- a/apm-collector/apm-collector-storage/src/main/java/org/skywalking/apm/collector/storage/h2/dao/BatchH2DAO.java +++ b/apm-collector/apm-collector-storage/src/main/java/org/skywalking/apm/collector/storage/h2/dao/BatchH2DAO.java @@ -1,14 +1,73 @@ package org.skywalking.apm.collector.storage.h2.dao; -import java.util.List; +import org.skywalking.apm.collector.client.h2.H2ClientException; import org.skywalking.apm.collector.storage.dao.IBatchDAO; +import org.skywalking.apm.collector.storage.h2.define.H2SqlEntity; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import java.sql.Connection; +import java.sql.PreparedStatement; +import java.sql.SQLException; +import java.util.HashMap; +import java.util.List; +import java.util.Map; /** * @author pengys5 */ public class BatchH2DAO extends H2DAO implements IBatchDAO { + private final Logger logger = LoggerFactory.getLogger(BatchH2DAO.class); + private final Map batchSqls = new HashMap<>(); - @Override public void batchPersistence(List batchCollection) { + @Override + public void batchPersistence(List batchCollection) { + if (batchCollection != null && batchCollection.size() > 0) { + logger.info("the batch collection size is {}", batchCollection.size()); + Connection conn = null; + try { + conn = getClient().getConnection(); + conn.setAutoCommit(false); + PreparedStatement ps; + for (Object entity : batchCollection) { + H2SqlEntity e = getH2SqlEntity(entity); + String sql = e.getSql(); + if (batchSqls.containsKey(sql)) { + ps = batchSqls.get(sql); + } else { + ps = conn.prepareStatement(sql); + batchSqls.put(sql, ps); + } + Object[] params = e.getParams(); + if (params != null) { + logger.info("the sql is {}, params size is {}", e.getSql(), params.length); + for (int i = 0; i < params.length; i++) { + ps.setObject(i + 1, params[i]); + } + } + ps.addBatch(); + } + + for (String k : batchSqls.keySet()) { + batchSqls.get(k).executeBatch(); + } + conn.commit(); + } catch (SQLException | H2ClientException e) { + logger.error(e.getMessage(), e); + try { + conn.rollback(); + } catch (SQLException e1) { + logger.error(e.getMessage(), e1); + } + } + } + } + + private H2SqlEntity getH2SqlEntity(Object entity) { + if (entity instanceof H2SqlEntity) { + return (H2SqlEntity) entity; + } + return null; } } diff --git a/apm-collector/apm-collector-storage/src/main/java/org/skywalking/apm/collector/storage/h2/dao/H2DAO.java b/apm-collector/apm-collector-storage/src/main/java/org/skywalking/apm/collector/storage/h2/dao/H2DAO.java index 1d703e954..f094c4063 100644 --- a/apm-collector/apm-collector-storage/src/main/java/org/skywalking/apm/collector/storage/h2/dao/H2DAO.java +++ b/apm-collector/apm-collector-storage/src/main/java/org/skywalking/apm/collector/storage/h2/dao/H2DAO.java @@ -8,6 +8,7 @@ import org.slf4j.LoggerFactory; import java.sql.ResultSet; import java.sql.SQLException; +import java.util.Set; /** * @author pengys5 @@ -26,9 +27,7 @@ public abstract class H2DAO extends DAO { public final int getIntValueBySQL(String sql) { H2Client client = getClient(); - ResultSet rs = null; - try { - rs = client.executeQuery(sql, null); + try (ResultSet rs = client.executeQuery(sql, null)) { if (rs.next()) { int id = rs.getInt(1); if (id == Integer.MAX_VALUE || id == Integer.MIN_VALUE) { @@ -39,9 +38,34 @@ public abstract class H2DAO extends DAO { } } catch (SQLException | H2ClientException e) { logger.error(e.getMessage(), e); - } finally { - client.closeResultSet(rs); } return 0; } + + public final String getBatchInsertSql(String tableName, Set columnNames) { + StringBuilder sb = new StringBuilder("insert into "); + sb.append(tableName).append("("); + columnNames.forEach((columnName) -> { + sb.append(columnName).append(","); + }); + sb.delete(sb.length() - 1, sb.length()); + sb.append(") values("); + for (int i = 0; i < columnNames.size(); i++) { + sb.append("?,"); + } + sb.delete(sb.length() - 1, sb.length()); + sb.append(")"); + return sb.toString(); + } + + public final String getBatchUpdateSql(String tableName, Set columnNames, String whereClauseName) { + StringBuilder sb = new StringBuilder("update "); + sb.append(tableName).append(" "); + columnNames.forEach((columnName) -> { + sb.append("set ").append(columnName).append("=?,"); + }); + sb.delete(sb.length() - 1, sb.length()); + sb.append(" where ").append(whereClauseName).append("=?"); + return sb.toString(); + } } diff --git a/apm-collector/apm-collector-storage/src/main/java/org/skywalking/apm/collector/storage/h2/define/H2SqlEntity.java b/apm-collector/apm-collector-storage/src/main/java/org/skywalking/apm/collector/storage/h2/define/H2SqlEntity.java new file mode 100644 index 000000000..c36c21d46 --- /dev/null +++ b/apm-collector/apm-collector-storage/src/main/java/org/skywalking/apm/collector/storage/h2/define/H2SqlEntity.java @@ -0,0 +1,22 @@ +package org.skywalking.apm.collector.storage.h2.define; + +public class H2SqlEntity { + private String sql; + private Object[] params; + + public String getSql() { + return sql; + } + + public void setSql(String sql) { + this.sql = sql; + } + + public Object[] getParams() { + return params; + } + + public void setParams(Object[] params) { + this.params = params; + } +} diff --git a/apm-collector/apm-collector-storage/src/main/java/org/skywalking/apm/collector/storage/h2/define/H2StorageInstaller.java b/apm-collector/apm-collector-storage/src/main/java/org/skywalking/apm/collector/storage/h2/define/H2StorageInstaller.java index 12718a66c..20ecf15c8 100644 --- a/apm-collector/apm-collector-storage/src/main/java/org/skywalking/apm/collector/storage/h2/define/H2StorageInstaller.java +++ b/apm-collector/apm-collector-storage/src/main/java/org/skywalking/apm/collector/storage/h2/define/H2StorageInstaller.java @@ -1,10 +1,5 @@ package org.skywalking.apm.collector.storage.h2.define; -import java.sql.ResultSet; -import java.sql.SQLException; -import java.util.List; - -import org.h2.util.IOUtils; import org.skywalking.apm.collector.client.h2.H2Client; import org.skywalking.apm.collector.client.h2.H2ClientException; import org.skywalking.apm.collector.core.client.Client; @@ -15,6 +10,10 @@ import org.skywalking.apm.collector.core.storage.TableDefine; import org.slf4j.Logger; import org.slf4j.LoggerFactory; +import java.sql.ResultSet; +import java.sql.SQLException; +import java.util.List; + /** * @author pengys5 */ 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 7809287a4..149d73202 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 @@ -1,13 +1,36 @@ 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.ApplicationTable; 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 */ public class ApplicationH2DAO extends H2DAO implements IApplicationDAO { + private final Logger logger = LoggerFactory.getLogger(ApplicationH2DAO.class); + private static final String GET_APPLICATION_CODE_SQL = "select {0} from {1} where {2} = ?"; @Override public String getApplicationCode(int applicationId) { - return null; + logger.debug("get application code, applicationId: {}", applicationId); + H2Client client = getClient(); + String sql = MessageFormat.format(GET_APPLICATION_CODE_SQL, ApplicationTable.COLUMN_APPLICATION_CODE, ApplicationTable.TABLE, ApplicationTable.COLUMN_APPLICATION_ID); + Object[] params = new Object[]{applicationId}; + try (ResultSet rs = client.executeQuery(sql, params)) { + if (rs.next()) { + return rs.getString(1); + } + } catch (SQLException | H2ClientException e) { + logger.error(e.getMessage(), e); + } + return Const.UNKNOWN; } } 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 new file mode 100644 index 000000000..6cd009208 --- /dev/null +++ b/apm-collector/apm-collector-ui/src/main/java/org/skywalking/apm/collector/ui/dao/CpuMetricH2DAO.java @@ -0,0 +1,81 @@ +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; + +import java.sql.ResultSet; +import java.sql.SQLException; +import java.text.MessageFormat; +import java.util.ArrayList; +import java.util.List; + +/** + * @author pengys5 + */ +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 ("; + @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"); + Object[] params = new Object[]{id}; + try (ResultSet rs = client.executeQuery(sql, params)) { + if (rs.next()) { + return rs.getInt(CpuMetricTable.COLUMN_USAGE_PERCENT); + } + } catch (SQLException | H2ClientException e) { + logger.error(e.getMessage(), e); + } + return 0; + } + + @Override public JsonArray getMetric(int instanceId, long startTimeBucket, long endTimeBucket) { + H2Client client = getClient(); + String sql = MessageFormat.format(GET_METRICS_SQL, CpuMetricTable.TABLE, "id"); + + long timeBucket = startTimeBucket; + List idList = new ArrayList<>(); + do { + timeBucket = TimeBucketUtils.INSTANCE.addSecondForSecondTimeBucket(TimeBucketUtils.TimeBucketType.SECOND.name(), timeBucket, 1); + String id = timeBucket + Const.ID_SPLIT + instanceId; + 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]); + + JsonArray metrics = new JsonArray(); + try (ResultSet rs = client.executeQuery(sql, params)) { + while (rs.next()) { + double cpuUsed = rs.getDouble(CpuMetricTable.COLUMN_USAGE_PERCENT); + metrics.add((int)(cpuUsed * 100)); + } + } catch (SQLException | H2ClientException e) { + logger.error(e.getMessage(), e); + } + return metrics; + } +} 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 b72d5d3d4..bf38132df 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 @@ -2,14 +2,19 @@ package org.skywalking.apm.collector.ui.dao; import com.google.gson.JsonObject; import org.skywalking.apm.collector.storage.h2.dao.H2DAO; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; /** * @author pengys5 */ 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}"; @Override public GCCount getGCCount(long[] timeBuckets, int instanceId) { - return null; + GCCount gcCount = new GCCount(); + + return gcCount; } @Override public JsonObject getMetric(int instanceId, long timeBucket) { 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 7dc331d19..c11ac37c9 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 @@ -1,30 +1,156 @@ package org.skywalking.apm.collector.ui.dao; import com.google.gson.JsonArray; +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.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; + +import java.sql.ResultSet; +import java.sql.SQLException; +import java.text.MessageFormat; +import java.util.ArrayList; +import java.util.List; /** * @author pengys5 */ public class InstPerformanceH2DAO extends H2DAO implements IInstPerformanceDAO { - + private final Logger logger = LoggerFactory.getLogger(InstPerformanceH2DAO.class); + private static final String GET_INST_PERF_SQL = "select * from {0} where {1} = ? and {2} in ("; + private static final String GET_TPS_METRIC_SQL = "select * from {0} where {1} = ?"; + private static final String GET_TPS_METRICS_SQL = "select * from {0} where {1} in ("; @Override public InstPerformance get(long[] timeBuckets, int instanceId) { + H2Client client = getClient(); + 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++ ) { + 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++) { + params[i + 1] = timeBuckets[i]; + } + params[0] = instanceId; + try (ResultSet rs = client.executeQuery(sql, params)) { + if (rs.next()) { + int callTimes = rs.getInt(InstPerformanceTable.COLUMN_CALLS); + int costTotal = rs.getInt(InstPerformanceTable.COLUMN_COST_TOTAL); + return new InstPerformance(instanceId, callTimes, costTotal); + } + } catch (SQLException | H2ClientException e) { + logger.error(e.getMessage(), e); + } return null; } @Override public int getTpsMetric(int instanceId, long timeBucket) { + H2Client client = getClient(); + String sql = MessageFormat.format(GET_TPS_METRIC_SQL, InstPerformanceTable.TABLE, "id"); + Object[] params = new Object[]{instanceId}; + try (ResultSet rs = client.executeQuery(sql, params)) { + if (rs.next()) { + return rs.getInt(InstPerformanceTable.COLUMN_CALLS); + } + } catch (SQLException | H2ClientException e) { + logger.error(e.getMessage(), e); + } return 0; } @Override public JsonArray getTpsMetric(int instanceId, long startTimeBucket, long endTimeBucket) { - return null; + H2Client client = getClient(); + String sql = MessageFormat.format(GET_TPS_METRICS_SQL, InstPerformanceTable.TABLE, "id"); + + long timeBucket = startTimeBucket; + List idList = new ArrayList<>(); + do { + String id = timeBucket + Const.ID_SPLIT + instanceId; + timeBucket = TimeBucketUtils.INSTANCE.addSecondForSecondTimeBucket(TimeBucketUtils.TimeBucketType.SECOND.name(), timeBucket, 1); + 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]); + + JsonArray metrics = new JsonArray(); + try (ResultSet rs = client.executeQuery(sql, params)) { + while (rs.next()) { + int calls = rs.getInt(InstPerformanceTable.COLUMN_CALLS); + metrics.add(calls); + } + } catch (SQLException | H2ClientException e) { + logger.error(e.getMessage(), e); + } + return metrics; } @Override public int getRespTimeMetric(int instanceId, long timeBucket) { + H2Client client = getClient(); + String sql = MessageFormat.format(GET_TPS_METRIC_SQL, InstPerformanceTable.TABLE, "id"); + Object[] params = new Object[]{instanceId}; + try (ResultSet rs = client.executeQuery(sql, params)) { + if (rs.next()) { + int callTimes = rs.getInt(InstPerformanceTable.COLUMN_CALLS); + int costTotal = rs.getInt(InstPerformanceTable.COLUMN_COST_TOTAL); + return costTotal / callTimes; + } + } catch (SQLException | H2ClientException e) { + logger.error(e.getMessage(), e); + } return 0; } @Override public JsonArray getRespTimeMetric(int instanceId, long startTimeBucket, long endTimeBucket) { - return null; + H2Client client = getClient(); + String sql = MessageFormat.format(GET_TPS_METRICS_SQL, InstPerformanceTable.TABLE, "id"); + + long timeBucket = startTimeBucket; + List idList = new ArrayList<>(); + do { + String id = timeBucket + Const.ID_SPLIT + instanceId; + timeBucket = TimeBucketUtils.INSTANCE.addSecondForSecondTimeBucket(TimeBucketUtils.TimeBucketType.SECOND.name(), timeBucket, 1); + 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]); + + JsonArray metrics = new JsonArray(); + try (ResultSet rs = client.executeQuery(sql, params)) { + while (rs.next()) { + int callTimes = rs.getInt(InstPerformanceTable.COLUMN_CALLS); + int costTotal = rs.getInt(InstPerformanceTable.COLUMN_COST_TOTAL); + metrics.add(costTotal / callTimes); + } + } catch (SQLException | H2ClientException e) { + logger.error(e.getMessage(), e); + } + return metrics; } } 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 0f7028bbe..02412a367 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,31 +1,135 @@ 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; +import org.skywalking.apm.collector.ui.cache.ApplicationCache; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; /** * @author pengys5 */ public class InstanceH2DAO extends H2DAO implements IInstanceDAO { - @Override public Long lastHeartBeatTime() { + private final Logger logger = LoggerFactory.getLogger(InstanceH2DAO.class); + private static final String GET_LAST_HEARTBEAT_TIME_SQL = "select {0} from {1} where {2} > ? limit 1"; + private static final String GET_INST_LAST_HEARTBEAT_TIME_SQL = "select {0} from {1} where {2} > ? and {3} = ? limit 1"; + private static final String GET_INSTANCE_SQL = "select * from {0} where {1} = ?"; + private static final String GET_INSTANCES_SQL = "select * from {0} where {1} = ? and {2} >= ?"; + private static final String GET_APPLICATIONS_SQL = "select {3}, count({0}) as cnt from {1} where {2} >= ? and {2} <= ? group by {3} limit 100"; + + @Override + public Long lastHeartBeatTime() { + H2Client client = getClient(); + long fiveMinuteBefore = System.currentTimeMillis() - 5 * 60 * 1000; + fiveMinuteBefore = TimeBucketUtils.INSTANCE.getSecondTimeBucket(fiveMinuteBefore); + String sql = MessageFormat.format(GET_LAST_HEARTBEAT_TIME_SQL, InstanceTable.COLUMN_HEARTBEAT_TIME, InstanceTable.TABLE, InstanceTable.COLUMN_HEARTBEAT_TIME); + Object[] params = new Object[]{fiveMinuteBefore}; + try (ResultSet rs = client.executeQuery(sql, params)) { + if (rs.next()) { + return rs.getLong(1); + } + } catch (SQLException | H2ClientException e) { + logger.error(e.getMessage(), e); + } + return 0L; + } + + @Override + public Long instanceLastHeartBeatTime(long applicationInstanceId) { + H2Client client = getClient(); + 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); + Object[] params = new Object[]{fiveMinuteBefore, applicationInstanceId}; + try (ResultSet rs = client.executeQuery(sql, params)) { + if (rs.next()) { + return rs.getLong(1); + } + } catch (SQLException | H2ClientException e) { + logger.error(e.getMessage(), e); + } + return 0L; + } + + @Override + public JsonArray getApplications(long startTime, long endTime) { + H2Client client = getClient(); + JsonArray applications = new JsonArray(); + String sql = MessageFormat.format(GET_APPLICATIONS_SQL, InstanceTable.COLUMN_INSTANCE_ID, + InstanceTable.TABLE, InstanceTable.COLUMN_HEARTBEAT_TIME, InstanceTable.COLUMN_APPLICATION_ID); + Object[] params = new Object[]{startTime, endTime}; + try (ResultSet rs = client.executeQuery(sql, params)) { + while (rs.next()) { + Integer applicationId = rs.getInt(InstanceTable.COLUMN_APPLICATION_ID); + logger.debug("applicationId: {}", applicationId); + JsonObject application = new JsonObject(); + application.addProperty("applicationId", applicationId); + application.addProperty("applicationCode", ApplicationCache.getForUI(applicationId)); + application.addProperty("instanceCount", rs.getInt("cnt")); + applications.add(application); + } + } catch (SQLException | H2ClientException e) { + logger.error(e.getMessage(), e); + } + return applications; + } + + @Override + public InstanceDataDefine.Instance getInstance(int instanceId) { + H2Client client = getClient(); + String sql = MessageFormat.format(GET_INSTANCE_SQL, InstanceTable.TABLE, InstanceTable.COLUMN_INSTANCE_ID); + Object[] params = new Object[]{instanceId}; + try (ResultSet rs = client.executeQuery(sql, params)) { + if (rs.next()) { + InstanceDataDefine.Instance instance = new InstanceDataDefine.Instance(); + instance.setId(String.valueOf(instanceId)); + instance.setApplicationId(rs.getInt(InstanceTable.COLUMN_APPLICATION_ID)); + instance.setAgentUUID(rs.getString(InstanceTable.COLUMN_AGENT_UUID)); + instance.setRegisterTime(rs.getLong(InstanceTable.COLUMN_REGISTER_TIME)); + instance.setHeartBeatTime(rs.getLong(InstanceTable.COLUMN_HEARTBEAT_TIME)); + instance.setOsInfo(rs.getString(InstanceTable.COLUMN_OS_INFO)); + return instance; + } + } catch (SQLException | H2ClientException e) { + logger.error(e.getMessage(), e); + } return null; } - @Override public Long instanceLastHeartBeatTime(long applicationInstanceId) { - return null; - } - - @Override public JsonArray getApplications(long startTime, long endTime) { - return null; - } - - @Override public InstanceDataDefine.Instance getInstance(int instanceId) { - return null; - } - - @Override public List getInstances(int applicationId, long timeBucket) { - return null; + @Override + public List getInstances(int applicationId, long timeBucket) { + logger.debug("get instances info, application id: {}, timeBucket: {}", applicationId, timeBucket); + List instanceList = new LinkedList<>(); + H2Client client = getClient(); + String sql = MessageFormat.format(GET_INSTANCES_SQL, InstanceTable.TABLE, InstanceTable.COLUMN_APPLICATION_ID, InstanceTable.COLUMN_HEARTBEAT_TIME); + Object[] params = new Object[]{applicationId, timeBucket}; + try (ResultSet rs = client.executeQuery(sql, params)) { + while (rs.next()) { + InstanceDataDefine.Instance instance = new InstanceDataDefine.Instance(); + instance.setApplicationId(rs.getInt(InstanceTable.COLUMN_APPLICATION_ID)); + instance.setHeartBeatTime(rs.getLong(InstanceTable.COLUMN_HEARTBEAT_TIME)); + instance.setInstanceId(rs.getInt(InstanceTable.COLUMN_INSTANCE_ID)); + instanceList.add(instance); + } + } catch (SQLException | H2ClientException e) { + logger.error(e.getMessage(), e); + } + return instanceList; } } 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 5a73d42ce..e3f818691 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 @@ -1,14 +1,62 @@ 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.StringUtils; +import org.skywalking.apm.collector.storage.define.node.NodeComponentTable; 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; /** * @author pengys5 */ public class NodeComponentH2DAO extends H2DAO implements INodeComponentDAO { - + private final Logger logger = LoggerFactory.getLogger(NodeComponentH2DAO.class); + private static final String AGGREGATE_COMPONENT_SQL = "select * from {3} where {4} >= ? and {4} <= ? group by {0}, {1}, {2} limit 100"; @Override public JsonArray load(long startTime, long endTime) { - return null; + JsonArray nodeComponentArray = new JsonArray(); + nodeComponentArray.addAll(aggregationComponent(startTime, endTime)); + return nodeComponentArray; + } + private JsonArray aggregationComponent(long startTime, long endTime) { + H2Client client = getClient(); + + JsonArray nodeComponentArray = new JsonArray(); + String sql = MessageFormat.format(AGGREGATE_COMPONENT_SQL, NodeComponentTable.COLUMN_COMPONENT_ID, + NodeComponentTable.COLUMN_PEER, NodeComponentTable.COLUMN_PEER_ID, + NodeComponentTable.TABLE, NodeComponentTable.COLUMN_TIME_BUCKET); + Object[] params = new Object[]{startTime, endTime}; + try (ResultSet rs = client.executeQuery(sql, params)) { + while (rs.next()) { + int peerId = rs.getInt(NodeComponentTable.COLUMN_PEER_ID); + String componentName = rs.getString(NodeComponentTable.COLUMN_COMPONENT_NAME); + if (peerId != 0) { + String peer = ApplicationCache.getForUI(peerId); + nodeComponentArray.add(buildNodeComponent(peer, componentName)); + } + String peer = rs.getString(NodeComponentTable.COLUMN_PEER); + if (StringUtils.isNotEmpty(peer)) { + nodeComponentArray.add(buildNodeComponent(peer, componentName)); + } + } + } catch (SQLException | H2ClientException e) { + logger.error(e.getMessage(), e); + } + return nodeComponentArray; + } + + private JsonObject buildNodeComponent(String peer, String componentName) { + JsonObject nodeComponentObj = new JsonObject(); + nodeComponentObj.addProperty("componentName", componentName); + nodeComponentObj.addProperty("peer", peer); + return nodeComponentObj; } } 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 afda33070..6fb2cea3c 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 @@ -1,14 +1,58 @@ 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.StringUtils; +import org.skywalking.apm.collector.storage.define.node.NodeMappingTable; 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; /** * @author pengys5 */ public class NodeMappingH2DAO extends H2DAO implements INodeMappingDAO { - + private final Logger logger = LoggerFactory.getLogger(NodeMappingH2DAO.class); + private static final String NODE_MAPPING_SQL = "select * from {3} where {4} >= ? and {4} <= ? group by {0}, {1}, {2} limit 100"; @Override public JsonArray load(long startTime, long endTime) { - return null; + H2Client client = getClient(); + JsonArray nodeMappingArray = new JsonArray(); + String sql = MessageFormat.format(NODE_MAPPING_SQL, NodeMappingTable.COLUMN_APPLICATION_ID, + NodeMappingTable.COLUMN_ADDRESS_ID, NodeMappingTable.COLUMN_ADDRESS, + NodeMappingTable.TABLE, NodeMappingTable.COLUMN_TIME_BUCKET); + + Object[] params = new Object[]{startTime, endTime}; + try (ResultSet rs = client.executeQuery(sql, params)) { + while (rs.next()) { + int applicationId = rs.getInt(NodeMappingTable.COLUMN_APPLICATION_ID); + String applicationCode = ApplicationCache.getForUI(applicationId); + int addressId = rs.getInt(NodeMappingTable.COLUMN_ADDRESS_ID); + if (addressId != 0) { + String address = ApplicationCache.getForUI(addressId); + JsonObject nodeMappingObj = new JsonObject(); + nodeMappingObj.addProperty("applicationCode", applicationCode); + nodeMappingObj.addProperty("address", address); + nodeMappingArray.add(nodeMappingObj); + } + String address = rs.getString(NodeMappingTable.COLUMN_ADDRESS); + if (StringUtils.isNotEmpty(address)) { + JsonObject nodeMappingObj = new JsonObject(); + nodeMappingObj.addProperty("applicationCode", applicationCode); + nodeMappingObj.addProperty("address", address); + nodeMappingArray.add(nodeMappingObj); + } + } + } catch (SQLException | H2ClientException e) { + logger.error(e.getMessage(), e); + } + logger.debug("node mapping data: {}", nodeMappingArray.toString()); + return nodeMappingArray; } } 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 72c6cd65e..ab9df2fdb 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 @@ -1,13 +1,74 @@ 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.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; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import java.sql.ResultSet; +import java.sql.SQLException; +import java.text.MessageFormat; /** * @author pengys5 */ public class NodeReferenceH2DAO extends H2DAO implements INodeReferenceDAO { + private final Logger logger = LoggerFactory.getLogger(NodeReferenceH2DAO.class); + private static final String NODE_REFERENCE_SQL = "select {8}, {9}, {10}, sum({0}) as {0}, sum({1}) as {1}, sum({2}) as {2}, " + + "sum({3}) as {3}, sum({4}) as {4}, sum({5}) as {5} from {6} where {7} >= ? and {7} <= ? group by {8}, {9}, {10} limit 100"; @Override public JsonArray load(long startTime, long endTime) { - return null; + H2Client client = getClient(); + JsonArray nodeRefResSumArray = new JsonArray(); + String sql = MessageFormat.format(NODE_REFERENCE_SQL, NodeReferenceTable.COLUMN_S1_LTE, + NodeReferenceTable.COLUMN_S3_LTE, NodeReferenceTable.COLUMN_S5_LTE, + NodeReferenceTable.COLUMN_S5_GT, NodeReferenceTable.COLUMN_SUMMARY, + NodeReferenceTable.COLUMN_ERROR, NodeReferenceTable.TABLE, NodeReferenceTable.COLUMN_TIME_BUCKET, + NodeReferenceTable.COLUMN_FRONT_APPLICATION_ID, NodeReferenceTable.COLUMN_BEHIND_APPLICATION_ID, NodeReferenceTable.COLUMN_BEHIND_PEER); + + Object[] params = new Object[]{startTime, endTime}; + try (ResultSet rs = client.executeQuery(sql, params)) { + while (rs.next()) { + int applicationId = rs.getInt(NodeReferenceTable.COLUMN_FRONT_APPLICATION_ID); + String applicationCode = ApplicationCache.getForUI(applicationId); + int behindApplicationId = rs.getInt(NodeReferenceTable.COLUMN_BEHIND_APPLICATION_ID); + if (behindApplicationId != 0) { + String behindApplicationCode = ApplicationCache.getForUI(behindApplicationId); + + JsonObject nodeRefResSumObj = new JsonObject(); + nodeRefResSumObj.addProperty("front", applicationCode); + nodeRefResSumObj.addProperty("behind", behindApplicationCode); + nodeRefResSumObj.addProperty(NodeReferenceTable.COLUMN_S1_LTE, rs.getDouble(NodeReferenceTable.COLUMN_S1_LTE)); + nodeRefResSumObj.addProperty(NodeReferenceTable.COLUMN_S3_LTE, rs.getDouble(NodeReferenceTable.COLUMN_S3_LTE)); + nodeRefResSumObj.addProperty(NodeReferenceTable.COLUMN_S5_LTE, rs.getDouble(NodeReferenceTable.COLUMN_S5_LTE)); + nodeRefResSumObj.addProperty(NodeReferenceTable.COLUMN_S5_GT, rs.getDouble(NodeReferenceTable.COLUMN_S5_GT)); + nodeRefResSumObj.addProperty(NodeReferenceTable.COLUMN_ERROR, rs.getDouble(NodeReferenceTable.COLUMN_ERROR)); + nodeRefResSumObj.addProperty(NodeReferenceTable.COLUMN_SUMMARY, rs.getDouble(NodeReferenceTable.COLUMN_SUMMARY)); + nodeRefResSumArray.add(nodeRefResSumObj); + } + String behindPeer = rs.getString(NodeReferenceTable.COLUMN_BEHIND_PEER); + if (StringUtils.isNotEmpty(behindPeer)) { + JsonObject nodeRefResSumObj = new JsonObject(); + nodeRefResSumObj.addProperty("front", applicationCode); + nodeRefResSumObj.addProperty("behind", behindPeer); + nodeRefResSumObj.addProperty(NodeReferenceTable.COLUMN_S1_LTE, rs.getDouble(NodeReferenceTable.COLUMN_S1_LTE)); + nodeRefResSumObj.addProperty(NodeReferenceTable.COLUMN_S3_LTE, rs.getDouble(NodeReferenceTable.COLUMN_S3_LTE)); + nodeRefResSumObj.addProperty(NodeReferenceTable.COLUMN_S5_LTE, rs.getDouble(NodeReferenceTable.COLUMN_S5_LTE)); + nodeRefResSumObj.addProperty(NodeReferenceTable.COLUMN_S5_GT, rs.getDouble(NodeReferenceTable.COLUMN_S5_GT)); + nodeRefResSumObj.addProperty(NodeReferenceTable.COLUMN_ERROR, rs.getDouble(NodeReferenceTable.COLUMN_ERROR)); + nodeRefResSumObj.addProperty(NodeReferenceTable.COLUMN_SUMMARY, rs.getDouble(NodeReferenceTable.COLUMN_SUMMARY)); + nodeRefResSumArray.add(nodeRefResSumObj); + } + } + } catch (SQLException | H2ClientException e) { + logger.error(e.getMessage(), e); + } + return nodeRefResSumArray; } } diff --git a/apm-collector/apm-collector-ui/src/main/java/org/skywalking/apm/collector/ui/service/InstanceHealthService.java b/apm-collector/apm-collector-ui/src/main/java/org/skywalking/apm/collector/ui/service/InstanceHealthService.java index a29e509cc..1d5a0ee0b 100644 --- a/apm-collector/apm-collector-ui/src/main/java/org/skywalking/apm/collector/ui/service/InstanceHealthService.java +++ b/apm-collector/apm-collector-ui/src/main/java/org/skywalking/apm/collector/ui/service/InstanceHealthService.java @@ -41,10 +41,14 @@ public class InstanceHealthService { IGCMetricDAO gcMetricDAO = (IGCMetricDAO)DAOContainer.INSTANCE.get(IGCMetricDAO.class.getName()); JsonObject instanceJson = new JsonObject(); instanceJson.addProperty("id", instance.getInstanceId()); - instanceJson.addProperty("tps", performance.getCalls()); + if (performance != null) { + instanceJson.addProperty("tps", performance.getCalls()); + } else { + instanceJson.addProperty("tps", 0); + } int avg = 0; - if (performance.getCalls() != 0) { + if (performance != null && performance.getCalls() != 0) { avg = (int)(performance.getCostTotal() / performance.getCalls()); } instanceJson.addProperty("avg", avg); From d4333ff7e0f6842f7b21cc623544d70922d6b16e Mon Sep 17 00:00:00 2001 From: clevertension Date: Fri, 13 Oct 2017 15:04:15 +0800 Subject: [PATCH 3/7] add h2 support phase 2 --- .../application/dao/ApplicationH2DAO.java | 2 +- .../worker/instance/dao/InstanceH2DAO.java | 20 +-- .../node/mapping/dao/NodeMappingH2DAO.java | 1 + .../noderef/dao/NodeReferenceH2DAO.java | 73 +++++++++- .../define/NodeReferenceH2TableDefine.java | 1 + .../collector/ui/dao/ApplicationH2DAO.java | 2 +- .../apm/collector/ui/dao/CpuMetricH2DAO.java | 19 +-- .../apm/collector/ui/dao/GCMetricH2DAO.java | 137 +++++++++++++++++- .../collector/ui/dao/GlobalTraceH2DAO.java | 49 ++++++- .../ui/dao/InstPerformanceH2DAO.java | 15 +- .../apm/collector/ui/dao/InstanceH2DAO.java | 19 +-- .../collector/ui/dao/MemoryMetricH2DAO.java | 89 ++++++++++++ .../ui/dao/MemoryPoolMetricH2DAO.java | 89 ++++++++++++ .../collector/ui/dao/NodeComponentH2DAO.java | 2 +- .../collector/ui/dao/NodeMappingH2DAO.java | 2 +- .../collector/ui/dao/NodeReferenceH2DAO.java | 3 +- .../collector/ui/dao/SegmentCostH2DAO.java | 127 +++++++++++++++- .../apm/collector/ui/dao/SegmentH2DAO.java | 35 ++++- .../collector/ui/dao/ServiceEntryH2DAO.java | 66 ++++++++- .../collector/ui/dao/ServiceNameH2DAO.java | 41 +++++- .../resources/META-INF/defines/h2_dao.define | 3 + 21 files changed, 727 insertions(+), 68 deletions(-) create mode 100644 apm-collector/apm-collector-ui/src/main/java/org/skywalking/apm/collector/ui/dao/MemoryMetricH2DAO.java create mode 100644 apm-collector/apm-collector-ui/src/main/java/org/skywalking/apm/collector/ui/dao/MemoryPoolMetricH2DAO.java 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 6f45a62cb..41cfe8493 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 6b7ccc612..d90036ce3 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 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; +import org.skywalking.apm.collector.client.h2.H2Client; +import org.skywalking.apm.collector.client.h2.H2ClientException; +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; + /** * @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 2f8712c3d..63ed26551 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 f03932c9f..8ca8bf048 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 43b8377c8..cfa8d9174 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 149d73202..4aa3f2c7a 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 6cd009208..fe378dc61 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 bf38132df..614a886d8 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 5e4082386..6d8c3977b 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 c11ac37c9..a09ee871c 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 02412a367..88a563c1e 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 000000000..0a94da62f --- /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 000000000..cde5bfcc0 --- /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 e3f818691..a5cc16bc0 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 6fb2cea3c..95cacb37a 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 ab9df2fdb..f6e1169cd 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 1621927b2..21443371f 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 06b55d904..fd58c0fdf 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 da811365d..8c6bb83e0 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 f0f585651..71db6ffc0 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 d110e3684..742176e4d 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 From dfba63defbfb47197ecededdd9a2ec1d9ff6ec7f Mon Sep 17 00:00:00 2001 From: clevertension Date: Fri, 13 Oct 2017 17:47:09 +0800 Subject: [PATCH 4/7] add h2 support phase 3 --- .../worker/cpu/dao/CpuMetricH2DAO.java | 2 +- .../agentjvm/worker/gc/dao/GCMetricH2DAO.java | 2 +- .../heartbeat/dao/InstanceHeartBeatH2DAO.java | 2 +- .../worker/memory/dao/MemoryMetricH2DAO.java | 2 +- .../memorypool/dao/MemoryPoolMetricH2DAO.java | 2 +- .../application/dao/ApplicationH2DAO.java | 2 +- .../worker/instance/dao/InstanceH2DAO.java | 2 +- .../servicename/dao/ServiceNameH2DAO.java | 74 ++++++++++++++++--- .../worker/global/dao/GlobalTraceH2DAO.java | 5 +- .../performance/dao/InstPerformanceH2DAO.java | 2 +- .../component/dao/NodeComponentH2DAO.java | 2 +- .../node/mapping/dao/NodeMappingH2DAO.java | 2 +- .../noderef/dao/NodeReferenceH2DAO.java | 7 +- .../segment/cost/dao/SegmentCostH2DAO.java | 2 +- .../segment/origin/dao/SegmentH2DAO.java | 4 +- .../service/entry/dao/ServiceEntryH2DAO.java | 10 ++- .../serviceref/dao/ServiceReferenceH2DAO.java | 2 +- .../src/main/resources/application.yml | 33 +++++---- .../define/segment/SegmentCostDataDefine.java | 2 +- .../collector/storage/h2/dao/BatchH2DAO.java | 5 +- .../apm/collector/storage/h2/dao/H2DAO.java | 4 +- .../collector/ui/dao/NodeComponentH2DAO.java | 6 +- .../collector/ui/dao/NodeMappingH2DAO.java | 2 +- .../collector/ui/dao/SegmentCostH2DAO.java | 40 +++++----- 24 files changed, 139 insertions(+), 77 deletions(-) diff --git a/apm-collector/apm-collector-agentjvm/src/main/java/org/skywalking/apm/collector/agentjvm/worker/cpu/dao/CpuMetricH2DAO.java b/apm-collector/apm-collector-agentjvm/src/main/java/org/skywalking/apm/collector/agentjvm/worker/cpu/dao/CpuMetricH2DAO.java index 169dec800..1ef42a6f1 100644 --- a/apm-collector/apm-collector-agentjvm/src/main/java/org/skywalking/apm/collector/agentjvm/worker/cpu/dao/CpuMetricH2DAO.java +++ b/apm-collector/apm-collector-agentjvm/src/main/java/org/skywalking/apm/collector/agentjvm/worker/cpu/dao/CpuMetricH2DAO.java @@ -13,7 +13,7 @@ import java.util.HashMap; import java.util.Map; /** - * @author pengys5 + * @author pengys5, clevertension */ public class CpuMetricH2DAO extends H2DAO implements ICpuMetricDAO, IPersistenceDAO { private final Logger logger = LoggerFactory.getLogger(CpuMetricH2DAO.class); diff --git a/apm-collector/apm-collector-agentjvm/src/main/java/org/skywalking/apm/collector/agentjvm/worker/gc/dao/GCMetricH2DAO.java b/apm-collector/apm-collector-agentjvm/src/main/java/org/skywalking/apm/collector/agentjvm/worker/gc/dao/GCMetricH2DAO.java index 268762ec9..5a949a305 100644 --- a/apm-collector/apm-collector-agentjvm/src/main/java/org/skywalking/apm/collector/agentjvm/worker/gc/dao/GCMetricH2DAO.java +++ b/apm-collector/apm-collector-agentjvm/src/main/java/org/skywalking/apm/collector/agentjvm/worker/gc/dao/GCMetricH2DAO.java @@ -11,7 +11,7 @@ import java.util.HashMap; import java.util.Map; /** - * @author pengys5 + * @author pengys5, clevertension */ public class GCMetricH2DAO extends H2DAO implements IGCMetricDAO, IPersistenceDAO { @Override public Data get(String id, DataDefine dataDefine) { diff --git a/apm-collector/apm-collector-agentjvm/src/main/java/org/skywalking/apm/collector/agentjvm/worker/heartbeat/dao/InstanceHeartBeatH2DAO.java b/apm-collector/apm-collector-agentjvm/src/main/java/org/skywalking/apm/collector/agentjvm/worker/heartbeat/dao/InstanceHeartBeatH2DAO.java index 9a6cd29ca..1ab0ebb79 100644 --- a/apm-collector/apm-collector-agentjvm/src/main/java/org/skywalking/apm/collector/agentjvm/worker/heartbeat/dao/InstanceHeartBeatH2DAO.java +++ b/apm-collector/apm-collector-agentjvm/src/main/java/org/skywalking/apm/collector/agentjvm/worker/heartbeat/dao/InstanceHeartBeatH2DAO.java @@ -18,7 +18,7 @@ import java.text.MessageFormat; import java.util.*; /** - * @author pengys5 + * @author pengys5, clevertension */ public class InstanceHeartBeatH2DAO extends H2DAO implements IInstanceHeartBeatDAO, IPersistenceDAO { private final Logger logger = LoggerFactory.getLogger(InstanceHeartBeatEsDAO.class); diff --git a/apm-collector/apm-collector-agentjvm/src/main/java/org/skywalking/apm/collector/agentjvm/worker/memory/dao/MemoryMetricH2DAO.java b/apm-collector/apm-collector-agentjvm/src/main/java/org/skywalking/apm/collector/agentjvm/worker/memory/dao/MemoryMetricH2DAO.java index 1f15524a3..8bd334fa4 100644 --- a/apm-collector/apm-collector-agentjvm/src/main/java/org/skywalking/apm/collector/agentjvm/worker/memory/dao/MemoryMetricH2DAO.java +++ b/apm-collector/apm-collector-agentjvm/src/main/java/org/skywalking/apm/collector/agentjvm/worker/memory/dao/MemoryMetricH2DAO.java @@ -11,7 +11,7 @@ import java.util.HashMap; import java.util.Map; /** - * @author pengys5 + * @author pengys5, clevertension */ public class MemoryMetricH2DAO extends H2DAO implements IMemoryMetricDAO, IPersistenceDAO { @Override public Data get(String id, DataDefine dataDefine) { diff --git a/apm-collector/apm-collector-agentjvm/src/main/java/org/skywalking/apm/collector/agentjvm/worker/memorypool/dao/MemoryPoolMetricH2DAO.java b/apm-collector/apm-collector-agentjvm/src/main/java/org/skywalking/apm/collector/agentjvm/worker/memorypool/dao/MemoryPoolMetricH2DAO.java index 64a8638ba..b7cc3369a 100644 --- a/apm-collector/apm-collector-agentjvm/src/main/java/org/skywalking/apm/collector/agentjvm/worker/memorypool/dao/MemoryPoolMetricH2DAO.java +++ b/apm-collector/apm-collector-agentjvm/src/main/java/org/skywalking/apm/collector/agentjvm/worker/memorypool/dao/MemoryPoolMetricH2DAO.java @@ -11,7 +11,7 @@ import java.util.HashMap; import java.util.Map; /** - * @author pengys5 + * @author pengys5, clevertension */ public class MemoryPoolMetricH2DAO extends H2DAO implements IMemoryPoolMetricDAO, IPersistenceDAO { @Override public Data get(String id, DataDefine dataDefine) { 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 41cfe8493..01efc7ca0 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 @@ -11,7 +11,7 @@ import org.slf4j.LoggerFactory; import java.text.MessageFormat; /** - * @author pengys5 + * @author pengys5, clevertension */ public class ApplicationH2DAO extends H2DAO implements IApplicationDAO { private final Logger logger = LoggerFactory.getLogger(ApplicationH2DAO.class); 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 d90036ce3..80e7dd547 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 @@ -15,7 +15,7 @@ import org.slf4j.Logger; import org.slf4j.LoggerFactory; /** - * @author pengys5 + * @author pengys5, clevertension */ public class InstanceH2DAO extends H2DAO implements IInstanceDAO { private final Logger logger = LoggerFactory.getLogger(InstanceH2DAO.class); diff --git a/apm-collector/apm-collector-agentregister/src/main/java/org/skywalking/apm/collector/agentregister/worker/servicename/dao/ServiceNameH2DAO.java b/apm-collector/apm-collector-agentregister/src/main/java/org/skywalking/apm/collector/agentregister/worker/servicename/dao/ServiceNameH2DAO.java index 1c463e798..75624034c 100644 --- a/apm-collector/apm-collector-agentregister/src/main/java/org/skywalking/apm/collector/agentregister/worker/servicename/dao/ServiceNameH2DAO.java +++ b/apm-collector/apm-collector-agentregister/src/main/java/org/skywalking/apm/collector/agentregister/worker/servicename/dao/ServiceNameH2DAO.java @@ -1,30 +1,86 @@ package org.skywalking.apm.collector.agentregister.worker.servicename.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.ServiceNameDataDefine; +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; +import java.util.HashMap; +import java.util.Map; /** - * @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_ID_SQL = "select {0} from {1} where {2} = ? and {3} = ? limit 1"; + private static final String GET_SERVICE_NAME_SQL = "select {0} from {1} where {2} = ?"; - @Override public int getServiceId(int applicationId, String serviceName) { + @Override + public int getServiceId(int applicationId, String serviceName) { + H2Client client = getClient(); + String sql = MessageFormat.format(GET_SERVICE_ID_SQL, ServiceNameTable.COLUMN_SERVICE_ID, ServiceNameTable.COLUMN_SERVICE_NAME, + 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()) { + return rs.getInt(ServiceNameTable.COLUMN_SERVICE_ID); + } + } catch (SQLException | H2ClientException e) { + logger.error(e.getMessage(), e); + } return 0; } - @Override public int getMaxServiceId() { - return 0; + @Override + public int getMaxServiceId() { + return getMaxId(ServiceNameTable.TABLE, ServiceNameTable.COLUMN_SERVICE_ID); } - @Override public int getMinServiceId() { - return 0; + @Override + public int getMinServiceId() { + return getMinId(ServiceNameTable.TABLE, ServiceNameTable.COLUMN_SERVICE_ID); } - @Override public String getServiceName(int serviceId) { - return null; + + @Override + public String getServiceName(int serviceId) { + 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.EMPTY_STRING; } - @Override public void save(ServiceNameDataDefine.ServiceName serviceName) { + @Override + public void save(ServiceNameDataDefine.ServiceName serviceName) { + logger.debug("save service name register info, application id: {}, service name: {}", serviceName.getApplicationId(), serviceName.getServiceName()); + H2Client client = getClient(); + Map source = new HashMap(); + source.put(ServiceNameTable.COLUMN_SERVICE_ID, serviceName.getServiceId()); + source.put(ServiceNameTable.COLUMN_APPLICATION_ID, serviceName.getApplicationId()); + source.put(ServiceNameTable.COLUMN_SERVICE_NAME, serviceName.getServiceName()); + String sql = getBatchInsertSql(ServiceNameTable.TABLE, source.keySet()); + Object[] params = source.values().toArray(new Object[0]); + try { + client.execute(sql, params); + } catch (H2ClientException e) { + logger.error(e.getMessage(), e); + } } } diff --git a/apm-collector/apm-collector-agentstream/src/main/java/org/skywalking/apm/collector/agentstream/worker/global/dao/GlobalTraceH2DAO.java b/apm-collector/apm-collector-agentstream/src/main/java/org/skywalking/apm/collector/agentstream/worker/global/dao/GlobalTraceH2DAO.java index 05dee62ab..f81461640 100644 --- a/apm-collector/apm-collector-agentstream/src/main/java/org/skywalking/apm/collector/agentstream/worker/global/dao/GlobalTraceH2DAO.java +++ b/apm-collector/apm-collector-agentstream/src/main/java/org/skywalking/apm/collector/agentstream/worker/global/dao/GlobalTraceH2DAO.java @@ -4,7 +4,6 @@ import org.skywalking.apm.collector.core.framework.UnexpectedException; import org.skywalking.apm.collector.core.stream.Data; import org.skywalking.apm.collector.storage.define.DataDefine; import org.skywalking.apm.collector.storage.define.global.GlobalTraceTable; -import org.skywalking.apm.collector.storage.define.node.NodeComponentTable; 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; @@ -15,7 +14,7 @@ import java.util.HashMap; import java.util.Map; /** - * @author pengys5 + * @author pengys5, clevertension */ public class GlobalTraceH2DAO extends H2DAO implements IGlobalTraceDAO, IPersistenceDAO { private final Logger logger = LoggerFactory.getLogger(GlobalTraceH2DAO.class); @@ -36,7 +35,7 @@ public class GlobalTraceH2DAO extends H2DAO implements IGlobalTraceDAO, IPersist source.put(GlobalTraceTable.COLUMN_TIME_BUCKET, data.getDataLong(0)); logger.debug("global trace source: {}", source.toString()); - String sql = getBatchInsertSql(NodeComponentTable.TABLE, source.keySet()); + String sql = getBatchInsertSql(GlobalTraceTable.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/instance/performance/dao/InstPerformanceH2DAO.java b/apm-collector/apm-collector-agentstream/src/main/java/org/skywalking/apm/collector/agentstream/worker/instance/performance/dao/InstPerformanceH2DAO.java index 418191320..194954015 100644 --- a/apm-collector/apm-collector-agentstream/src/main/java/org/skywalking/apm/collector/agentstream/worker/instance/performance/dao/InstPerformanceH2DAO.java +++ b/apm-collector/apm-collector-agentstream/src/main/java/org/skywalking/apm/collector/agentstream/worker/instance/performance/dao/InstPerformanceH2DAO.java @@ -17,7 +17,7 @@ import java.text.MessageFormat; import java.util.*; /** - * @author pengys5 + * @author pengys5, clevertension */ public class InstPerformanceH2DAO extends H2DAO implements IInstPerformanceDAO, IPersistenceDAO { private final Logger logger = LoggerFactory.getLogger(InstPerformanceH2DAO.class); diff --git a/apm-collector/apm-collector-agentstream/src/main/java/org/skywalking/apm/collector/agentstream/worker/node/component/dao/NodeComponentH2DAO.java b/apm-collector/apm-collector-agentstream/src/main/java/org/skywalking/apm/collector/agentstream/worker/node/component/dao/NodeComponentH2DAO.java index 98f0797f7..d73377548 100644 --- a/apm-collector/apm-collector-agentstream/src/main/java/org/skywalking/apm/collector/agentstream/worker/node/component/dao/NodeComponentH2DAO.java +++ b/apm-collector/apm-collector-agentstream/src/main/java/org/skywalking/apm/collector/agentstream/worker/node/component/dao/NodeComponentH2DAO.java @@ -18,7 +18,7 @@ import java.text.MessageFormat; import java.util.*; /** - * @author pengys5 + * @author pengys5, clevertension */ public class NodeComponentH2DAO extends H2DAO implements INodeComponentDAO, IPersistenceDAO { private final Logger logger = LoggerFactory.getLogger(NodeComponentH2DAO.class); 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 63ed26551..1695dc6b7 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 @@ -18,7 +18,7 @@ import java.text.MessageFormat; import java.util.*; /** - * @author pengys5 + * @author pengys5, clevertension */ public class NodeMappingH2DAO extends H2DAO implements INodeMappingDAO, IPersistenceDAO { private final Logger logger = LoggerFactory.getLogger(NodeComponentH2DAO.class); 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 8ca8bf048..144b3bf3a 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 @@ -4,7 +4,6 @@ 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; @@ -21,7 +20,7 @@ import java.util.List; import java.util.Map; /** - * @author pengys5 + * @author pengys5, clevertension */ public class NodeReferenceH2DAO extends H2DAO implements INodeReferenceDAO, IPersistenceDAO { private final Logger logger = LoggerFactory.getLogger(NodeReferenceH2DAO.class); @@ -64,7 +63,7 @@ public class NodeReferenceH2DAO extends H2DAO implements INodeReferenceDAO, IPer 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()); + String sql = getBatchInsertSql(NodeReferenceTable.TABLE, source.keySet()); entity.setSql(sql); entity.setParams(source.values().toArray(new Object[0])); @@ -84,7 +83,7 @@ public class NodeReferenceH2DAO extends H2DAO implements INodeReferenceDAO, IPer 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"); + String sql = getBatchUpdateSql(NodeReferenceTable.TABLE, source.keySet(), "id"); entity.setSql(sql); List values = new ArrayList<>(source.values()); values.add(id); diff --git a/apm-collector/apm-collector-agentstream/src/main/java/org/skywalking/apm/collector/agentstream/worker/segment/cost/dao/SegmentCostH2DAO.java b/apm-collector/apm-collector-agentstream/src/main/java/org/skywalking/apm/collector/agentstream/worker/segment/cost/dao/SegmentCostH2DAO.java index 77f9f2628..033490b11 100644 --- a/apm-collector/apm-collector-agentstream/src/main/java/org/skywalking/apm/collector/agentstream/worker/segment/cost/dao/SegmentCostH2DAO.java +++ b/apm-collector/apm-collector-agentstream/src/main/java/org/skywalking/apm/collector/agentstream/worker/segment/cost/dao/SegmentCostH2DAO.java @@ -13,7 +13,7 @@ import java.util.HashMap; import java.util.Map; /** - * @author pengys5 + * @author pengys5, clevertension */ public class SegmentCostH2DAO extends H2DAO implements ISegmentCostDAO, IPersistenceDAO { private final Logger logger = LoggerFactory.getLogger(SegmentCostH2DAO.class); diff --git a/apm-collector/apm-collector-agentstream/src/main/java/org/skywalking/apm/collector/agentstream/worker/segment/origin/dao/SegmentH2DAO.java b/apm-collector/apm-collector-agentstream/src/main/java/org/skywalking/apm/collector/agentstream/worker/segment/origin/dao/SegmentH2DAO.java index 1d78a8434..7bed7041b 100644 --- a/apm-collector/apm-collector-agentstream/src/main/java/org/skywalking/apm/collector/agentstream/worker/segment/origin/dao/SegmentH2DAO.java +++ b/apm-collector/apm-collector-agentstream/src/main/java/org/skywalking/apm/collector/agentstream/worker/segment/origin/dao/SegmentH2DAO.java @@ -15,7 +15,7 @@ import java.util.HashMap; import java.util.Map; /** - * @author pengys5 + * @author pengys5, clevertension */ public class SegmentH2DAO extends H2DAO implements ISegmentDAO, IPersistenceDAO { private final Logger logger = LoggerFactory.getLogger(SegmentCostH2DAO.class); @@ -26,7 +26,7 @@ public class SegmentH2DAO extends H2DAO implements ISegmentDAO, IPersistenceDAO< Map source = new HashMap<>(); H2SqlEntity entity = new H2SqlEntity(); source.put("id", data.getDataString(0)); - source.put(SegmentTable.COLUMN_DATA_BINARY, new String(Base64.getEncoder().encode(data.getDataBytes(0)))); + source.put(SegmentTable.COLUMN_DATA_BINARY, Base64.getEncoder().encode(data.getDataBytes(0))); logger.debug("segment source: {}", source.toString()); String sql = getBatchInsertSql(SegmentTable.TABLE, source.keySet()); diff --git a/apm-collector/apm-collector-agentstream/src/main/java/org/skywalking/apm/collector/agentstream/worker/service/entry/dao/ServiceEntryH2DAO.java b/apm-collector/apm-collector-agentstream/src/main/java/org/skywalking/apm/collector/agentstream/worker/service/entry/dao/ServiceEntryH2DAO.java index aa182958e..a9cdc98ed 100644 --- a/apm-collector/apm-collector-agentstream/src/main/java/org/skywalking/apm/collector/agentstream/worker/service/entry/dao/ServiceEntryH2DAO.java +++ b/apm-collector/apm-collector-agentstream/src/main/java/org/skywalking/apm/collector/agentstream/worker/service/entry/dao/ServiceEntryH2DAO.java @@ -5,7 +5,6 @@ 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.service.ServiceEntryTable; -import org.skywalking.apm.collector.storage.define.serviceref.ServiceReferenceTable; 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; @@ -14,16 +13,19 @@ import org.slf4j.LoggerFactory; import java.sql.ResultSet; import java.sql.SQLException; -import java.util.*; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; /** - * @author pengys5 + * @author pengys5, clevertension */ public class ServiceEntryH2DAO extends H2DAO implements IServiceEntryDAO, IPersistenceDAO { private final Logger logger = LoggerFactory.getLogger(ServiceEntryH2DAO.class); @Override public Data get(String id, DataDefine dataDefine) { H2Client client = getClient(); - String sql = "select * from " + ServiceReferenceTable.TABLE + " where id = ?"; + String sql = "select * from " + ServiceEntryTable.TABLE + " where id = ?"; Object[] params = new Object[] {id}; try (ResultSet rs = client.executeQuery(sql, params)) { Data data = dataDefine.build(id); diff --git a/apm-collector/apm-collector-agentstream/src/main/java/org/skywalking/apm/collector/agentstream/worker/serviceref/dao/ServiceReferenceH2DAO.java b/apm-collector/apm-collector-agentstream/src/main/java/org/skywalking/apm/collector/agentstream/worker/serviceref/dao/ServiceReferenceH2DAO.java index 5cf648dea..ef69e8673 100644 --- a/apm-collector/apm-collector-agentstream/src/main/java/org/skywalking/apm/collector/agentstream/worker/serviceref/dao/ServiceReferenceH2DAO.java +++ b/apm-collector/apm-collector-agentstream/src/main/java/org/skywalking/apm/collector/agentstream/worker/serviceref/dao/ServiceReferenceH2DAO.java @@ -17,7 +17,7 @@ import java.text.MessageFormat; import java.util.*; /** - * @author pengys5 + * @author pengys5, clevertension */ public class ServiceReferenceH2DAO extends H2DAO implements IServiceReferenceDAO, IPersistenceDAO { private final Logger logger = LoggerFactory.getLogger(ServiceReferenceH2DAO.class); diff --git a/apm-collector/apm-collector-boot/src/main/resources/application.yml b/apm-collector/apm-collector-boot/src/main/resources/application.yml index dd9eefa56..df8a938fb 100644 --- a/apm-collector/apm-collector-boot/src/main/resources/application.yml +++ b/apm-collector/apm-collector-boot/src/main/resources/application.yml @@ -4,35 +4,36 @@ cluster: sessionTimeout: 100000 agent_server: jetty: - host: 127.0.0.1 + host: localhost port: 10800 context_path: / agent_stream: grpc: - host: 127.0.0.1 + host: localhost port: 11800 jetty: - host: 127.0.0.1 + host: localhost port: 12800 context_path: / ui: jetty: - host: 127.0.0.1 + host: localhost port: 12800 context_path: / collector_inside: grpc: - host: 127.0.0.1 + host: localhost port: 11800 -#storage: -# elasticsearch: -# cluster_name: CollectorDBCluster -# cluster_transport_sniffer: true -# cluster_nodes: localhost:9300 -# index_shards_number: 2 -# index_replicas_number: 0 storage: - h2: - url: jdbc:h2:~/collector - user_name: sa - password: sa \ No newline at end of file + elasticsearch: + cluster_name: CollectorDBCluster + cluster_transport_sniffer: true + cluster_nodes: localhost:9300 + index_shards_number: 2 + index_replicas_number: 0 +# uncomment to enable h2 storage +#storage: +# h2: +# url: jdbc:h2:~/collector +# user_name: sa +# password: sa \ No newline at end of file diff --git a/apm-collector/apm-collector-storage/src/main/java/org/skywalking/apm/collector/storage/define/segment/SegmentCostDataDefine.java b/apm-collector/apm-collector-storage/src/main/java/org/skywalking/apm/collector/storage/define/segment/SegmentCostDataDefine.java index d5bb081f2..ebb741252 100644 --- a/apm-collector/apm-collector-storage/src/main/java/org/skywalking/apm/collector/storage/define/segment/SegmentCostDataDefine.java +++ b/apm-collector/apm-collector-storage/src/main/java/org/skywalking/apm/collector/storage/define/segment/SegmentCostDataDefine.java @@ -10,7 +10,7 @@ import org.skywalking.apm.collector.storage.define.AttributeType; import org.skywalking.apm.collector.storage.define.DataDefine; /** - * @author pengys5 + * @author pengys5H */ public class SegmentCostDataDefine extends DataDefine { diff --git a/apm-collector/apm-collector-storage/src/main/java/org/skywalking/apm/collector/storage/h2/dao/BatchH2DAO.java b/apm-collector/apm-collector-storage/src/main/java/org/skywalking/apm/collector/storage/h2/dao/BatchH2DAO.java index 397f13bbb..f74b365c1 100644 --- a/apm-collector/apm-collector-storage/src/main/java/org/skywalking/apm/collector/storage/h2/dao/BatchH2DAO.java +++ b/apm-collector/apm-collector-storage/src/main/java/org/skywalking/apm/collector/storage/h2/dao/BatchH2DAO.java @@ -18,13 +18,13 @@ import java.util.Map; */ public class BatchH2DAO extends H2DAO implements IBatchDAO { private final Logger logger = LoggerFactory.getLogger(BatchH2DAO.class); - private final Map batchSqls = new HashMap<>(); @Override public void batchPersistence(List batchCollection) { if (batchCollection != null && batchCollection.size() > 0) { - logger.info("the batch collection size is {}", batchCollection.size()); + logger.info("the batch collection size is {}, current thread id {}", batchCollection.size()); Connection conn = null; + final Map batchSqls = new HashMap<>(); try { conn = getClient().getConnection(); conn.setAutoCommit(false); @@ -61,6 +61,7 @@ public class BatchH2DAO extends H2DAO implements IBatchDAO { logger.error(e.getMessage(), e1); } } + batchSqls.clear(); } } diff --git a/apm-collector/apm-collector-storage/src/main/java/org/skywalking/apm/collector/storage/h2/dao/H2DAO.java b/apm-collector/apm-collector-storage/src/main/java/org/skywalking/apm/collector/storage/h2/dao/H2DAO.java index f094c4063..03ba900ba 100644 --- a/apm-collector/apm-collector-storage/src/main/java/org/skywalking/apm/collector/storage/h2/dao/H2DAO.java +++ b/apm-collector/apm-collector-storage/src/main/java/org/skywalking/apm/collector/storage/h2/dao/H2DAO.java @@ -60,9 +60,9 @@ public abstract class H2DAO extends DAO { public final String getBatchUpdateSql(String tableName, Set columnNames, String whereClauseName) { StringBuilder sb = new StringBuilder("update "); - sb.append(tableName).append(" "); + sb.append(tableName).append(" set "); columnNames.forEach((columnName) -> { - sb.append("set ").append(columnName).append("=?,"); + sb.append(columnName).append("=?,"); }); sb.delete(sb.length() - 1, sb.length()); sb.append(" where ").append(whereClauseName).append("=?"); 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 a5cc16bc0..8fc1cfe87 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 @@ -8,6 +8,7 @@ import org.skywalking.apm.collector.core.util.StringUtils; import org.skywalking.apm.collector.storage.define.node.NodeComponentTable; import org.skywalking.apm.collector.storage.h2.dao.H2DAO; import org.skywalking.apm.collector.ui.cache.ApplicationCache; +import org.skywalking.apm.network.trace.component.ComponentsDefine; import org.slf4j.Logger; import org.slf4j.LoggerFactory; @@ -20,7 +21,7 @@ import java.text.MessageFormat; */ public class NodeComponentH2DAO extends H2DAO implements INodeComponentDAO { private final Logger logger = LoggerFactory.getLogger(NodeComponentH2DAO.class); - private static final String AGGREGATE_COMPONENT_SQL = "select * from {3} where {4} >= ? and {4} <= ? group by {0}, {1}, {2} limit 100"; + private static final String AGGREGATE_COMPONENT_SQL = "select {0}, {1}, {2} from {3} where {4} >= ? and {4} <= ? group by {0}, {1}, {2} limit 100"; @Override public JsonArray load(long startTime, long endTime) { JsonArray nodeComponentArray = new JsonArray(); nodeComponentArray.addAll(aggregationComponent(startTime, endTime)); @@ -37,7 +38,8 @@ public class NodeComponentH2DAO extends H2DAO implements INodeComponentDAO { try (ResultSet rs = client.executeQuery(sql, params)) { while (rs.next()) { int peerId = rs.getInt(NodeComponentTable.COLUMN_PEER_ID); - String componentName = rs.getString(NodeComponentTable.COLUMN_COMPONENT_NAME); + int componentId = rs.getInt(NodeComponentTable.COLUMN_COMPONENT_ID); + String componentName = ComponentsDefine.getInstance().getComponentName(componentId); if (peerId != 0) { String peer = ApplicationCache.getForUI(peerId); nodeComponentArray.add(buildNodeComponent(peer, componentName)); 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 95cacb37a..5b29e8d15 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 @@ -20,7 +20,7 @@ import java.text.MessageFormat; */ public class NodeMappingH2DAO extends H2DAO implements INodeMappingDAO { private final Logger logger = LoggerFactory.getLogger(NodeMappingH2DAO.class); - private static final String NODE_MAPPING_SQL = "select * from {3} where {4} >= ? and {4} <= ? group by {0}, {1}, {2} limit 100"; + private static final String NODE_MAPPING_SQL = "select {0}, {1}, {2} from {3} where {4} >= ? and {4} <= ? group by {0}, {1}, {2} limit 100"; @Override public JsonArray load(long startTime, long endTime) { H2Client client = getClient(); JsonArray nodeMappingArray = new JsonArray(); 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 21443371f..7607b3e8e 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 @@ -106,27 +106,29 @@ public class SegmentCostH2DAO extends H2DAO implements ISegmentCostDAO { 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)); + while (rs.next()) { + 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)); + 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++; } - - 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); } From 35c23fc62db43c651d8624c4220bab945dad7c7a Mon Sep 17 00:00:00 2001 From: clevertension Date: Sat, 14 Oct 2017 15:34:25 +0800 Subject: [PATCH 5/7] add h2 support phase 4 --- .../servicename/dao/ServiceNameH2DAO.java | 2 +- .../service/entry/dao/ServiceEntryH2DAO.java | 16 +- .../src/main/resources/application.yml | 24 +- .../apm/collector/client/h2/H2Client.java | 4 +- .../collector/storage/h2/dao/BatchH2DAO.java | 4 +- .../collector/ui/dao/SegmentCostH2DAO.java | 22 +- .../collector/ui/dao/ServiceEntryH2DAO.java | 9 +- .../ui/dao/ServiceReferenceH2DAO.java | 248 +++++++++++++++++- 8 files changed, 291 insertions(+), 38 deletions(-) diff --git a/apm-collector/apm-collector-agentregister/src/main/java/org/skywalking/apm/collector/agentregister/worker/servicename/dao/ServiceNameH2DAO.java b/apm-collector/apm-collector-agentregister/src/main/java/org/skywalking/apm/collector/agentregister/worker/servicename/dao/ServiceNameH2DAO.java index 75624034c..86ffb6884 100644 --- a/apm-collector/apm-collector-agentregister/src/main/java/org/skywalking/apm/collector/agentregister/worker/servicename/dao/ServiceNameH2DAO.java +++ b/apm-collector/apm-collector-agentregister/src/main/java/org/skywalking/apm/collector/agentregister/worker/servicename/dao/ServiceNameH2DAO.java @@ -26,7 +26,7 @@ public class ServiceNameH2DAO extends H2DAO implements IServiceNameDAO { @Override public int getServiceId(int applicationId, String serviceName) { H2Client client = getClient(); - String sql = MessageFormat.format(GET_SERVICE_ID_SQL, ServiceNameTable.COLUMN_SERVICE_ID, ServiceNameTable.COLUMN_SERVICE_NAME, + 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)) { diff --git a/apm-collector/apm-collector-agentstream/src/main/java/org/skywalking/apm/collector/agentstream/worker/service/entry/dao/ServiceEntryH2DAO.java b/apm-collector/apm-collector-agentstream/src/main/java/org/skywalking/apm/collector/agentstream/worker/service/entry/dao/ServiceEntryH2DAO.java index a9cdc98ed..f6954e1c4 100644 --- a/apm-collector/apm-collector-agentstream/src/main/java/org/skywalking/apm/collector/agentstream/worker/service/entry/dao/ServiceEntryH2DAO.java +++ b/apm-collector/apm-collector-agentstream/src/main/java/org/skywalking/apm/collector/agentstream/worker/service/entry/dao/ServiceEntryH2DAO.java @@ -28,13 +28,15 @@ public class ServiceEntryH2DAO extends H2DAO implements IServiceEntryDAO, IPersi String sql = "select * from " + ServiceEntryTable.TABLE + " where id = ?"; Object[] params = new Object[] {id}; try (ResultSet rs = client.executeQuery(sql, params)) { - Data data = dataDefine.build(id); - data.setDataInteger(0, rs.getInt(ServiceEntryTable.COLUMN_APPLICATION_ID)); - data.setDataInteger(1, rs.getInt(ServiceEntryTable.COLUMN_ENTRY_SERVICE_ID)); - data.setDataString(1, rs.getString(ServiceEntryTable.COLUMN_ENTRY_SERVICE_NAME)); - data.setDataLong(0, rs.getLong(ServiceEntryTable.COLUMN_REGISTER_TIME)); - data.setDataLong(1, rs.getLong(ServiceEntryTable.COLUMN_NEWEST_TIME)); - return data; + if (rs.next()) { + Data data = dataDefine.build(id); + data.setDataInteger(0, rs.getInt(ServiceEntryTable.COLUMN_APPLICATION_ID)); + data.setDataInteger(1, rs.getInt(ServiceEntryTable.COLUMN_ENTRY_SERVICE_ID)); + data.setDataString(1, rs.getString(ServiceEntryTable.COLUMN_ENTRY_SERVICE_NAME)); + data.setDataLong(0, rs.getLong(ServiceEntryTable.COLUMN_REGISTER_TIME)); + data.setDataLong(1, rs.getLong(ServiceEntryTable.COLUMN_NEWEST_TIME)); + return data; + } } catch (SQLException | H2ClientException e) { logger.error(e.getMessage(), e); } diff --git a/apm-collector/apm-collector-boot/src/main/resources/application.yml b/apm-collector/apm-collector-boot/src/main/resources/application.yml index df8a938fb..f42daaa42 100644 --- a/apm-collector/apm-collector-boot/src/main/resources/application.yml +++ b/apm-collector/apm-collector-boot/src/main/resources/application.yml @@ -24,16 +24,16 @@ collector_inside: grpc: host: localhost port: 11800 -storage: - elasticsearch: - cluster_name: CollectorDBCluster - cluster_transport_sniffer: true - cluster_nodes: localhost:9300 - index_shards_number: 2 - index_replicas_number: 0 -# uncomment to enable h2 storage #storage: -# h2: -# url: jdbc:h2:~/collector -# user_name: sa -# password: sa \ No newline at end of file +# elasticsearch: +# cluster_name: CollectorDBCluster +# cluster_transport_sniffer: true +# cluster_nodes: localhost:9300 +# index_shards_number: 2 +# index_replicas_number: 0 +# uncomment to enable h2 storage +storage: + h2: + url: jdbc:h2:~/collector + user_name: sa + password: sa \ No newline at end of file diff --git a/apm-collector/apm-collector-client/src/main/java/org/skywalking/apm/collector/client/h2/H2Client.java b/apm-collector/apm-collector-client/src/main/java/org/skywalking/apm/collector/client/h2/H2Client.java index fb62a1b1b..f948c8103 100644 --- a/apm-collector/apm-collector-client/src/main/java/org/skywalking/apm/collector/client/h2/H2Client.java +++ b/apm-collector/apm-collector-client/src/main/java/org/skywalking/apm/collector/client/h2/H2Client.java @@ -64,7 +64,7 @@ public class H2Client implements Client { } public ResultSet executeQuery(String sql, Object[] params) throws H2ClientException { - logger.info("execute query with result: {}", sql); + logger.debug("execute query with result: {}", sql); ResultSet rs; PreparedStatement statement; try { @@ -83,7 +83,7 @@ public class H2Client implements Client { } public boolean execute(String sql, Object[] params) throws H2ClientException { - logger.info("execute insert/update/delete: {}", sql); + logger.debug("execute insert/update/delete: {}", sql); boolean flag; Connection conn = getConnection(); try (PreparedStatement statement = conn.prepareStatement(sql)) { diff --git a/apm-collector/apm-collector-storage/src/main/java/org/skywalking/apm/collector/storage/h2/dao/BatchH2DAO.java b/apm-collector/apm-collector-storage/src/main/java/org/skywalking/apm/collector/storage/h2/dao/BatchH2DAO.java index f74b365c1..06a317cc9 100644 --- a/apm-collector/apm-collector-storage/src/main/java/org/skywalking/apm/collector/storage/h2/dao/BatchH2DAO.java +++ b/apm-collector/apm-collector-storage/src/main/java/org/skywalking/apm/collector/storage/h2/dao/BatchH2DAO.java @@ -22,7 +22,7 @@ public class BatchH2DAO extends H2DAO implements IBatchDAO { @Override public void batchPersistence(List batchCollection) { if (batchCollection != null && batchCollection.size() > 0) { - logger.info("the batch collection size is {}, current thread id {}", batchCollection.size()); + logger.debug("the batch collection size is {}", batchCollection.size()); Connection conn = null; final Map batchSqls = new HashMap<>(); try { @@ -41,7 +41,7 @@ public class BatchH2DAO extends H2DAO implements IBatchDAO { Object[] params = e.getParams(); if (params != null) { - logger.info("the sql is {}, params size is {}", e.getSql(), params.length); + logger.debug("the sql is {}, params size is {}", e.getSql(), params.length); for (int i = 0; i < params.length; i++) { ps.setObject(i + 1, params[i]); } 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 7607b3e8e..99a2f292b 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,7 +1,11 @@ package org.skywalking.apm.collector.ui.dao; -import com.google.gson.JsonArray; -import com.google.gson.JsonObject; +import java.sql.ResultSet; +import java.sql.SQLException; +import java.text.MessageFormat; +import java.util.ArrayList; +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; @@ -14,11 +18,8 @@ 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; +import com.google.gson.JsonArray; +import com.google.gson.JsonObject; /** * @author pengys5, clevertension @@ -31,7 +32,9 @@ public class SegmentCostH2DAO extends H2DAO implements ISegmentCostDAO { H2Client client = getClient(); String sql = GET_SEGMENT_COST_SQL; List params = new ArrayList<>(); - List columns = new ArrayList<>(); + List columns = new ArrayList<>(); + columns.add(SegmentCostTable.TABLE); + columns.add(SegmentCostTable.COLUMN_TIME_BUCKET); params.add(startTime); params.add(endTime); int paramIndex = 1; @@ -95,7 +98,8 @@ public class SegmentCostH2DAO extends H2DAO implements ISegmentCostDAO { } sql = sql + " limit " + from + "," + limit; - sql = MessageFormat.format(sql, SegmentCostTable.TABLE, SegmentCostTable.COLUMN_TIME_BUCKET, columns); + MessageFormat messageFormat = new MessageFormat(sql); + sql = messageFormat.format(columns.toArray(new Object[0])); Object[] p = params.toArray(new Object[0]); JsonObject topSegPaging = new JsonObject(); 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 8c6bb83e0..0f665eee7 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 @@ -29,7 +29,10 @@ public class ServiceEntryH2DAO extends H2DAO implements IServiceEntryDAO { H2Client client = getClient(); String sql = GET_SERVICE_ENTRY_SQL; List params = new ArrayList<>(); - List columns = new ArrayList<>(); + List columns = new ArrayList<>(); + columns.add(ServiceEntryTable.TABLE); + columns.add(ServiceEntryTable.COLUMN_NEWEST_TIME); + columns.add(ServiceEntryTable.COLUMN_REGISTER_TIME); params.add(startTime); params.add(endTime); int paramIndex = 2; @@ -46,8 +49,8 @@ public class ServiceEntryH2DAO extends H2DAO implements IServiceEntryDAO { 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); + MessageFormat messageFormat = new MessageFormat(sql); + sql = messageFormat.format(columns.toArray(new Object[0])); Object[] p = params.toArray(new Object[0]); JsonArray serviceArray = new JsonArray(); JsonObject response = new JsonObject(); diff --git a/apm-collector/apm-collector-ui/src/main/java/org/skywalking/apm/collector/ui/dao/ServiceReferenceH2DAO.java b/apm-collector/apm-collector-ui/src/main/java/org/skywalking/apm/collector/ui/dao/ServiceReferenceH2DAO.java index 932d25c32..3aca564c0 100644 --- a/apm-collector/apm-collector-ui/src/main/java/org/skywalking/apm/collector/ui/dao/ServiceReferenceH2DAO.java +++ b/apm-collector/apm-collector-ui/src/main/java/org/skywalking/apm/collector/ui/dao/ServiceReferenceH2DAO.java @@ -1,18 +1,262 @@ 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.Iterator; +import java.util.LinkedHashMap; +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.util.ColumnNameUtils; +import org.skywalking.apm.collector.core.util.Const; +import org.skywalking.apm.collector.core.util.ObjectUtils; +import org.skywalking.apm.collector.core.util.StringUtils; +import org.skywalking.apm.collector.storage.define.serviceref.ServiceReferenceTable; import org.skywalking.apm.collector.storage.h2.dao.H2DAO; +import org.skywalking.apm.collector.ui.cache.ServiceIdCache; +import org.skywalking.apm.collector.ui.cache.ServiceNameCache; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import com.google.gson.JsonArray; +import com.google.gson.JsonObject; /** - * @author pengys5 + * @author pengys5, clevertension */ public class ServiceReferenceH2DAO extends H2DAO implements IServiceReferenceDAO { + private final Logger logger = LoggerFactory.getLogger(ServiceReferenceH2DAO.class); + + private static final String GET_SRV_REF_LOAD1 = "select {4}, {5}, {6}, {7}, sum({8}) as cnt1, sum({9}) as cnt2, sum({10}) as cnt3" + + ",sum({11}) as cnt4, sum({12}) cnt5, sum({13}) as cnt6, sum({14}) as cnt7 from {0} where {1} >= ? and {1} <= ? and {2} = ? and {3} = ? group by {4}, {5}, {6}, {7}"; + private static final String GET_SRV_REF_LOAD2 = "select {3}, {4}, {5}, {6}, sum({7}) as cnt1, sum({8}) as cnt2, sum({9}) as cnt3" + + ",sum({10}) as cnt4, sum({11}) cnt5, sum({12}) as cnt6, sum({13}) as cnt7 from {0} where {1} >= ? and {1} <= ? and {2} = ? group by {3}, {4}, {5}, {6}"; @Override public JsonArray load(int entryServiceId, long startTime, long endTime) { + H2Client client = getClient(); + String sql = MessageFormat.format(GET_SRV_REF_LOAD1, ServiceReferenceTable.TABLE, + ServiceReferenceTable.COLUMN_TIME_BUCKET, ServiceReferenceTable.COLUMN_ENTRY_SERVICE_ID, ServiceReferenceTable.COLUMN_ENTRY_SERVICE_NAME, + ServiceReferenceTable.COLUMN_FRONT_SERVICE_ID, ServiceReferenceTable.COLUMN_BEHIND_SERVICE_ID, + ServiceReferenceTable.COLUMN_FRONT_SERVICE_NAME, ServiceReferenceTable.COLUMN_BEHIND_SERVICE_NAME, + ServiceReferenceTable.COLUMN_S1_LTE, ServiceReferenceTable.COLUMN_S3_LTE, ServiceReferenceTable.COLUMN_S5_LTE, + ServiceReferenceTable.COLUMN_S5_GT, ServiceReferenceTable.COLUMN_ERROR, ServiceReferenceTable.COLUMN_SUMMARY, + ServiceReferenceTable.COLUMN_COST_SUMMARY); + String entryServiceName = ServiceNameCache.get(entryServiceId); + Object[] params = new Object[]{startTime, endTime, entryServiceId, entryServiceName}; + try (ResultSet rs = client.executeQuery(sql, params)) { + if (rs.next()) { + Map serviceReferenceMap = new LinkedHashMap<>(); + + int frontServiceId = rs.getInt(ServiceReferenceTable.COLUMN_FRONT_SERVICE_ID); + if (frontServiceId != 0) { + parseSubAggregate(serviceReferenceMap, rs, frontServiceId); + } + + String frontServiceName = rs.getString(ServiceReferenceTable.COLUMN_FRONT_SERVICE_NAME); + if (StringUtils.isNotEmpty(frontServiceName)) { + String[] serviceNames = frontServiceName.split(Const.ID_SPLIT); + int frontServiceId1 = ServiceIdCache.getForUI(Integer.parseInt(serviceNames[0]), serviceNames[1]); + parseSubAggregate(serviceReferenceMap, rs, frontServiceId1); + } + + JsonArray serviceReferenceArray = new JsonArray(); + JsonObject rootServiceReference = findRoot(serviceReferenceMap); + if (ObjectUtils.isNotEmpty(rootServiceReference)) { + serviceReferenceArray.add(rootServiceReference); + String id = rootServiceReference.get(ColumnNameUtils.INSTANCE.rename(ServiceReferenceTable.COLUMN_FRONT_SERVICE_ID)) + Const.ID_SPLIT + rootServiceReference.get(ColumnNameUtils.INSTANCE.rename(ServiceReferenceTable.COLUMN_BEHIND_SERVICE_ID)); + serviceReferenceMap.remove(id); + + int rootServiceId = rootServiceReference.get(ColumnNameUtils.INSTANCE.rename(ServiceReferenceTable.COLUMN_BEHIND_SERVICE_ID)).getAsInt(); + sortAsTree(rootServiceId, serviceReferenceArray, serviceReferenceMap); + } + return serviceReferenceArray; + } + } catch (SQLException | H2ClientException e) { + logger.error(e.getMessage(), e); + } return null; } @Override public JsonArray load(String entryServiceName, int entryApplicationId, long startTime, long endTime) { + H2Client client = getClient(); + String sql = MessageFormat.format(GET_SRV_REF_LOAD2, ServiceReferenceTable.TABLE, + ServiceReferenceTable.COLUMN_TIME_BUCKET, ServiceReferenceTable.COLUMN_ENTRY_SERVICE_NAME, + ServiceReferenceTable.COLUMN_FRONT_SERVICE_ID, ServiceReferenceTable.COLUMN_BEHIND_SERVICE_ID, + ServiceReferenceTable.COLUMN_FRONT_SERVICE_NAME, ServiceReferenceTable.COLUMN_BEHIND_SERVICE_NAME, + ServiceReferenceTable.COLUMN_S1_LTE, ServiceReferenceTable.COLUMN_S3_LTE, ServiceReferenceTable.COLUMN_S5_LTE, + ServiceReferenceTable.COLUMN_S5_GT, ServiceReferenceTable.COLUMN_ERROR, ServiceReferenceTable.COLUMN_SUMMARY, + ServiceReferenceTable.COLUMN_COST_SUMMARY); + entryServiceName = entryApplicationId + Const.ID_SPLIT + entryServiceName; + Object[] params = new Object[]{startTime, endTime, entryServiceName}; + int entryServiceId = ServiceIdCache.get(entryApplicationId, entryServiceName); + if (entryServiceId != 0) { + sql = MessageFormat.format(GET_SRV_REF_LOAD1, ServiceReferenceTable.TABLE, + ServiceReferenceTable.COLUMN_TIME_BUCKET, ServiceReferenceTable.COLUMN_ENTRY_SERVICE_ID, ServiceReferenceTable.COLUMN_ENTRY_SERVICE_NAME, + ServiceReferenceTable.COLUMN_FRONT_SERVICE_ID, ServiceReferenceTable.COLUMN_BEHIND_SERVICE_ID, + ServiceReferenceTable.COLUMN_FRONT_SERVICE_NAME, ServiceReferenceTable.COLUMN_BEHIND_SERVICE_NAME, + ServiceReferenceTable.COLUMN_S1_LTE, ServiceReferenceTable.COLUMN_S3_LTE, ServiceReferenceTable.COLUMN_S5_LTE, + ServiceReferenceTable.COLUMN_S5_GT, ServiceReferenceTable.COLUMN_ERROR, ServiceReferenceTable.COLUMN_SUMMARY, + ServiceReferenceTable.COLUMN_COST_SUMMARY); + params = new Object[]{startTime, endTime, entryServiceId, entryServiceName}; + } + + try (ResultSet rs = client.executeQuery(sql, params)) { + if (rs.next()) { + Map serviceReferenceMap = new LinkedHashMap<>(); + + int frontServiceId = rs.getInt(ServiceReferenceTable.COLUMN_FRONT_SERVICE_ID); + if (frontServiceId != 0) { + parseSubAggregate(serviceReferenceMap, rs, frontServiceId); + } + + String frontServiceName = rs.getString(ServiceReferenceTable.COLUMN_FRONT_SERVICE_NAME); + if (StringUtils.isNotEmpty(frontServiceName)) { + String[] serviceNames = frontServiceName.split(Const.ID_SPLIT); + int frontServiceId1 = ServiceIdCache.getForUI(Integer.parseInt(serviceNames[0]), serviceNames[1]); + parseSubAggregate(serviceReferenceMap, rs, frontServiceId1); + } + + JsonArray serviceReferenceArray = new JsonArray(); + JsonObject rootServiceReference = findRoot(serviceReferenceMap); + if (ObjectUtils.isNotEmpty(rootServiceReference)) { + serviceReferenceArray.add(rootServiceReference); + String id = rootServiceReference.get(ColumnNameUtils.INSTANCE.rename(ServiceReferenceTable.COLUMN_FRONT_SERVICE_ID)) + Const.ID_SPLIT + rootServiceReference.get(ColumnNameUtils.INSTANCE.rename(ServiceReferenceTable.COLUMN_BEHIND_SERVICE_ID)); + serviceReferenceMap.remove(id); + + int rootServiceId = rootServiceReference.get(ColumnNameUtils.INSTANCE.rename(ServiceReferenceTable.COLUMN_BEHIND_SERVICE_ID)).getAsInt(); + sortAsTree(rootServiceId, serviceReferenceArray, serviceReferenceMap); + } + return serviceReferenceArray; + } + } catch (SQLException | H2ClientException e) { + logger.error(e.getMessage(), e); + } return null; } + + private void parseSubAggregate(Map serviceReferenceMap, + ResultSet rs, + int frontServiceId) { + try { + int behindServiceId = rs.getInt(ServiceReferenceTable.COLUMN_BEHIND_SERVICE_ID); + if (behindServiceId != 0) { + long s1LteSum = rs.getLong("cnt1"); + long s3LteSum = rs.getLong("cnt2"); + long s5LteSum = rs.getLong("cnt3"); + long s5GtSum = rs.getLong("cnt3"); + long error = rs.getLong("cnt3"); + long summary = rs.getLong("cnt3"); + long costSum = rs.getLong("cnt3"); + + String frontServiceName = ServiceNameCache.getForUI(frontServiceId); + if (StringUtils.isNotEmpty(frontServiceName)) { + frontServiceName = frontServiceName.split(Const.ID_SPLIT)[1]; + } + String behindServiceName = ServiceNameCache.getForUI(behindServiceId); + if (StringUtils.isNotEmpty(frontServiceName)) { + behindServiceName = behindServiceName.split(Const.ID_SPLIT)[1]; + } + + JsonObject serviceReference = new JsonObject(); + serviceReference.addProperty(ColumnNameUtils.INSTANCE.rename(ServiceReferenceTable.COLUMN_FRONT_SERVICE_ID), frontServiceId); + serviceReference.addProperty(ColumnNameUtils.INSTANCE.rename(ServiceReferenceTable.COLUMN_FRONT_SERVICE_NAME), frontServiceName); + serviceReference.addProperty(ColumnNameUtils.INSTANCE.rename(ServiceReferenceTable.COLUMN_BEHIND_SERVICE_ID), behindServiceId); + serviceReference.addProperty(ColumnNameUtils.INSTANCE.rename(ServiceReferenceTable.COLUMN_BEHIND_SERVICE_NAME), behindServiceName); + serviceReference.addProperty(ColumnNameUtils.INSTANCE.rename(ServiceReferenceTable.COLUMN_S1_LTE), s1LteSum); + serviceReference.addProperty(ColumnNameUtils.INSTANCE.rename(ServiceReferenceTable.COLUMN_S3_LTE), s3LteSum); + serviceReference.addProperty(ColumnNameUtils.INSTANCE.rename(ServiceReferenceTable.COLUMN_S5_LTE), s5LteSum); + serviceReference.addProperty(ColumnNameUtils.INSTANCE.rename(ServiceReferenceTable.COLUMN_S5_GT), s5GtSum); + serviceReference.addProperty(ColumnNameUtils.INSTANCE.rename(ServiceReferenceTable.COLUMN_ERROR), error); + serviceReference.addProperty(ColumnNameUtils.INSTANCE.rename(ServiceReferenceTable.COLUMN_SUMMARY), summary); + serviceReference.addProperty(ColumnNameUtils.INSTANCE.rename(ServiceReferenceTable.COLUMN_COST_SUMMARY), costSum); + merge(serviceReferenceMap, serviceReference); + } + } catch (SQLException e) { + logger.error(e.getMessage(), e); + } + + try { + String behindServiceName = rs.getString(ServiceReferenceTable.COLUMN_BEHIND_SERVICE_NAME); + if (StringUtils.isNotEmpty(behindServiceName)) { + long s1LteSum = rs.getLong("cnt1"); + long s3LteSum = rs.getLong("cnt2"); + long s5LteSum = rs.getLong("cnt3"); + long s5GtSum = rs.getLong("cnt3"); + long error = rs.getLong("cnt3"); + long summary = rs.getLong("cnt3"); + long costSum = rs.getLong("cnt3"); + + String frontServiceName = ServiceNameCache.getForUI(frontServiceId); + String[] serviceNames = behindServiceName.split(Const.ID_SPLIT); + int behindServiceId = ServiceIdCache.getForUI(Integer.parseInt(serviceNames[0]), serviceNames[1]); + behindServiceName = serviceNames[1]; + + JsonObject serviceReference = new JsonObject(); + serviceReference.addProperty(ColumnNameUtils.INSTANCE.rename(ServiceReferenceTable.COLUMN_FRONT_SERVICE_ID), frontServiceId); + serviceReference.addProperty(ColumnNameUtils.INSTANCE.rename(ServiceReferenceTable.COLUMN_FRONT_SERVICE_NAME), frontServiceName); + serviceReference.addProperty(ColumnNameUtils.INSTANCE.rename(ServiceReferenceTable.COLUMN_BEHIND_SERVICE_ID), behindServiceId); + serviceReference.addProperty(ColumnNameUtils.INSTANCE.rename(ServiceReferenceTable.COLUMN_BEHIND_SERVICE_NAME), behindServiceName); + serviceReference.addProperty(ColumnNameUtils.INSTANCE.rename(ServiceReferenceTable.COLUMN_S1_LTE), s1LteSum); + serviceReference.addProperty(ColumnNameUtils.INSTANCE.rename(ServiceReferenceTable.COLUMN_S3_LTE), s3LteSum); + serviceReference.addProperty(ColumnNameUtils.INSTANCE.rename(ServiceReferenceTable.COLUMN_S5_LTE), s5LteSum); + serviceReference.addProperty(ColumnNameUtils.INSTANCE.rename(ServiceReferenceTable.COLUMN_S5_GT), s5GtSum); + serviceReference.addProperty(ColumnNameUtils.INSTANCE.rename(ServiceReferenceTable.COLUMN_ERROR), error); + serviceReference.addProperty(ColumnNameUtils.INSTANCE.rename(ServiceReferenceTable.COLUMN_SUMMARY), summary); + serviceReference.addProperty(ColumnNameUtils.INSTANCE.rename(ServiceReferenceTable.COLUMN_COST_SUMMARY), costSum); + merge(serviceReferenceMap, serviceReference); + } + } catch (SQLException e) { + logger.error(e.getMessage(), e); + } + } + + private void merge(Map serviceReferenceMap, JsonObject serviceReference) { + String id = serviceReference.get(ColumnNameUtils.INSTANCE.rename(ServiceReferenceTable.COLUMN_FRONT_SERVICE_ID)) + Const.ID_SPLIT + serviceReference.get(ColumnNameUtils.INSTANCE.rename(ServiceReferenceTable.COLUMN_BEHIND_SERVICE_ID)); + + if (serviceReferenceMap.containsKey(id)) { + JsonObject reference = serviceReferenceMap.get(id); + add(reference, serviceReference, ColumnNameUtils.INSTANCE.rename(ServiceReferenceTable.COLUMN_S1_LTE)); + add(reference, serviceReference, ColumnNameUtils.INSTANCE.rename(ServiceReferenceTable.COLUMN_S3_LTE)); + add(reference, serviceReference, ColumnNameUtils.INSTANCE.rename(ServiceReferenceTable.COLUMN_S5_LTE)); + add(reference, serviceReference, ColumnNameUtils.INSTANCE.rename(ServiceReferenceTable.COLUMN_S5_GT)); + add(reference, serviceReference, ColumnNameUtils.INSTANCE.rename(ServiceReferenceTable.COLUMN_ERROR)); + add(reference, serviceReference, ColumnNameUtils.INSTANCE.rename(ServiceReferenceTable.COLUMN_SUMMARY)); + add(reference, serviceReference, ColumnNameUtils.INSTANCE.rename(ServiceReferenceTable.COLUMN_COST_SUMMARY)); + } else { + serviceReferenceMap.put(id, serviceReference); + } + } + + private void add(JsonObject oldReference, JsonObject newReference, String key) { + long oldValue = oldReference.get(key).getAsLong(); + long newValue = newReference.get(key).getAsLong(); + oldReference.addProperty(key, oldValue + newValue); + } + + private JsonObject findRoot(Map serviceReferenceMap) { + for (JsonObject serviceReference : serviceReferenceMap.values()) { + int frontServiceId = serviceReference.get(ColumnNameUtils.INSTANCE.rename(ServiceReferenceTable.COLUMN_FRONT_SERVICE_ID)).getAsInt(); + if (frontServiceId == 1) { + return serviceReference; + } + } + return null; + } + + private void sortAsTree(int serviceId, JsonArray serviceReferenceArray, + Map serviceReferenceMap) { + Iterator iterator = serviceReferenceMap.values().iterator(); + while (iterator.hasNext()) { + JsonObject serviceReference = iterator.next(); + int frontServiceId = serviceReference.get(ColumnNameUtils.INSTANCE.rename(ServiceReferenceTable.COLUMN_FRONT_SERVICE_ID)).getAsInt(); + if (serviceId == frontServiceId) { + serviceReferenceArray.add(serviceReference); + + int behindServiceId = serviceReference.get(ColumnNameUtils.INSTANCE.rename(ServiceReferenceTable.COLUMN_BEHIND_SERVICE_ID)).getAsInt(); + sortAsTree(behindServiceId, serviceReferenceArray, serviceReferenceMap); + } + } + } } From 6d90f2b96bf7c95f79060bf4c3bbe4e68568e859 Mon Sep 17 00:00:00 2001 From: clevertension Date: Mon, 16 Oct 2017 13:36:02 +0800 Subject: [PATCH 6/7] polish code with sqlbuilder --- .../worker/cpu/dao/CpuMetricH2DAO.java | 3 +- .../agentjvm/worker/gc/dao/GCMetricH2DAO.java | 9 +-- .../heartbeat/dao/InstanceHeartBeatH2DAO.java | 17 +++--- .../worker/memory/dao/MemoryMetricH2DAO.java | 9 +-- .../memorypool/dao/MemoryPoolMetricH2DAO.java | 9 +-- .../application/dao/ApplicationH2DAO.java | 5 +- .../worker/instance/dao/InstanceH2DAO.java | 10 +-- .../servicename/dao/ServiceNameH2DAO.java | 18 +++--- .../worker/global/dao/GlobalTraceH2DAO.java | 3 +- .../performance/dao/InstPerformanceH2DAO.java | 19 +++--- .../component/dao/NodeComponentH2DAO.java | 19 +++--- .../node/mapping/dao/NodeMappingH2DAO.java | 19 +++--- .../noderef/dao/NodeReferenceH2DAO.java | 22 +++---- .../segment/cost/dao/SegmentCostH2DAO.java | 3 +- .../segment/origin/dao/SegmentH2DAO.java | 11 ++-- .../service/entry/dao/ServiceEntryH2DAO.java | 30 ++++----- .../serviceref/dao/ServiceReferenceH2DAO.java | 8 +-- .../apm/collector/storage/h2/SqlBuilder.java | 61 +++++++++++++++++++ .../apm/collector/storage/h2/dao/H2DAO.java | 33 +--------- .../collector/ui/dao/ApplicationH2DAO.java | 10 +-- .../apm/collector/ui/dao/CpuMetricH2DAO.java | 17 +++--- .../apm/collector/ui/dao/GCMetricH2DAO.java | 23 +++---- .../collector/ui/dao/GlobalTraceH2DAO.java | 16 ++--- .../ui/dao/InstPerformanceH2DAO.java | 23 +++---- .../apm/collector/ui/dao/InstanceH2DAO.java | 25 ++++---- .../collector/ui/dao/MemoryMetricH2DAO.java | 19 +++--- .../ui/dao/MemoryPoolMetricH2DAO.java | 19 +++--- .../collector/ui/dao/NodeComponentH2DAO.java | 13 ++-- .../collector/ui/dao/NodeMappingH2DAO.java | 13 ++-- .../collector/ui/dao/NodeReferenceH2DAO.java | 13 ++-- .../collector/ui/dao/SegmentCostH2DAO.java | 5 +- .../apm/collector/ui/dao/SegmentH2DAO.java | 13 ++-- .../collector/ui/dao/ServiceEntryH2DAO.java | 18 +++--- .../collector/ui/dao/ServiceNameH2DAO.java | 12 ++-- .../ui/dao/ServiceReferenceH2DAO.java | 8 +-- 35 files changed, 309 insertions(+), 246 deletions(-) create mode 100644 apm-collector/apm-collector-storage/src/main/java/org/skywalking/apm/collector/storage/h2/SqlBuilder.java diff --git a/apm-collector/apm-collector-agentjvm/src/main/java/org/skywalking/apm/collector/agentjvm/worker/cpu/dao/CpuMetricH2DAO.java b/apm-collector/apm-collector-agentjvm/src/main/java/org/skywalking/apm/collector/agentjvm/worker/cpu/dao/CpuMetricH2DAO.java index b08643f2a..349c15b5f 100644 --- a/apm-collector/apm-collector-agentjvm/src/main/java/org/skywalking/apm/collector/agentjvm/worker/cpu/dao/CpuMetricH2DAO.java +++ b/apm-collector/apm-collector-agentjvm/src/main/java/org/skywalking/apm/collector/agentjvm/worker/cpu/dao/CpuMetricH2DAO.java @@ -21,6 +21,7 @@ package org.skywalking.apm.collector.agentjvm.worker.cpu.dao; import org.skywalking.apm.collector.core.stream.Data; import org.skywalking.apm.collector.storage.define.DataDefine; import org.skywalking.apm.collector.storage.define.jvm.CpuMetricTable; +import org.skywalking.apm.collector.storage.h2.SqlBuilder; 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; @@ -48,7 +49,7 @@ public class CpuMetricH2DAO extends H2DAO implements ICpuMetricDAO, IPersistence source.put(CpuMetricTable.COLUMN_TIME_BUCKET, data.getDataLong(0)); logger.debug("prepare cpu metric batch insert, id: {}", data.getDataString(0)); - String sql = getBatchInsertSql(CpuMetricTable.TABLE, source.keySet()); + String sql = SqlBuilder.buildBatchInsertSql(CpuMetricTable.TABLE, source.keySet()); entity.setSql(sql); entity.setParams(source.values().toArray(new Object[0])); return entity; diff --git a/apm-collector/apm-collector-agentjvm/src/main/java/org/skywalking/apm/collector/agentjvm/worker/gc/dao/GCMetricH2DAO.java b/apm-collector/apm-collector-agentjvm/src/main/java/org/skywalking/apm/collector/agentjvm/worker/gc/dao/GCMetricH2DAO.java index f8627f712..bbe619015 100644 --- a/apm-collector/apm-collector-agentjvm/src/main/java/org/skywalking/apm/collector/agentjvm/worker/gc/dao/GCMetricH2DAO.java +++ b/apm-collector/apm-collector-agentjvm/src/main/java/org/skywalking/apm/collector/agentjvm/worker/gc/dao/GCMetricH2DAO.java @@ -18,16 +18,17 @@ package org.skywalking.apm.collector.agentjvm.worker.gc.dao; +import java.util.HashMap; +import java.util.Map; + import org.skywalking.apm.collector.core.stream.Data; import org.skywalking.apm.collector.storage.define.DataDefine; import org.skywalking.apm.collector.storage.define.jvm.GCMetricTable; +import org.skywalking.apm.collector.storage.h2.SqlBuilder; 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 java.util.HashMap; -import java.util.Map; - /** * @author pengys5, clevertension */ @@ -46,7 +47,7 @@ public class GCMetricH2DAO extends H2DAO implements IGCMetricDAO, IPersistenceDA source.put(GCMetricTable.COLUMN_TIME, data.getDataLong(1)); source.put(GCMetricTable.COLUMN_TIME_BUCKET, data.getDataLong(2)); - String sql = getBatchInsertSql(GCMetricTable.TABLE, source.keySet()); + String sql = SqlBuilder.buildBatchInsertSql(GCMetricTable.TABLE, source.keySet()); entity.setSql(sql); entity.setParams(source.values().toArray(new Object[0])); return entity; diff --git a/apm-collector/apm-collector-agentjvm/src/main/java/org/skywalking/apm/collector/agentjvm/worker/heartbeat/dao/InstanceHeartBeatH2DAO.java b/apm-collector/apm-collector-agentjvm/src/main/java/org/skywalking/apm/collector/agentjvm/worker/heartbeat/dao/InstanceHeartBeatH2DAO.java index 0f0ab62b8..ecc7f5418 100644 --- a/apm-collector/apm-collector-agentjvm/src/main/java/org/skywalking/apm/collector/agentjvm/worker/heartbeat/dao/InstanceHeartBeatH2DAO.java +++ b/apm-collector/apm-collector-agentjvm/src/main/java/org/skywalking/apm/collector/agentjvm/worker/heartbeat/dao/InstanceHeartBeatH2DAO.java @@ -18,23 +18,26 @@ package org.skywalking.apm.collector.agentjvm.worker.heartbeat.dao; +import java.sql.ResultSet; +import java.sql.SQLException; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +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.framework.UnexpectedException; import org.skywalking.apm.collector.core.stream.Data; import org.skywalking.apm.collector.storage.define.DataDefine; import org.skywalking.apm.collector.storage.define.register.InstanceTable; +import org.skywalking.apm.collector.storage.h2.SqlBuilder; 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.*; - /** * @author pengys5, clevertension */ @@ -43,7 +46,7 @@ public class InstanceHeartBeatH2DAO extends H2DAO implements IInstanceHeartBeatD private static final String GET_INSTANCE_HEARTBEAT_SQL = "select * from {0} where {1} = ?"; @Override public Data get(String id, DataDefine dataDefine) { H2Client client = getClient(); - String sql = MessageFormat.format(GET_INSTANCE_HEARTBEAT_SQL, InstanceTable.TABLE, InstanceTable.COLUMN_INSTANCE_ID); + String sql = SqlBuilder.buildSql(GET_INSTANCE_HEARTBEAT_SQL, InstanceTable.TABLE, InstanceTable.COLUMN_INSTANCE_ID); Object[] params = new Object[]{id}; try (ResultSet rs = client.executeQuery(sql, params)) { if (rs.next()) { @@ -66,7 +69,7 @@ public class InstanceHeartBeatH2DAO extends H2DAO implements IInstanceHeartBeatD H2SqlEntity entity = new H2SqlEntity(); Map source = new HashMap<>(); source.put(InstanceTable.COLUMN_HEARTBEAT_TIME, data.getDataLong(0)); - String sql = getBatchUpdateSql(InstanceTable.TABLE, source.keySet(), InstanceTable.COLUMN_APPLICATION_ID); + String sql = SqlBuilder.buildBatchUpdateSql(InstanceTable.TABLE, source.keySet(), InstanceTable.COLUMN_APPLICATION_ID); entity.setSql(sql); List params = new ArrayList<>(source.values()); params.add(data.getDataString(0)); diff --git a/apm-collector/apm-collector-agentjvm/src/main/java/org/skywalking/apm/collector/agentjvm/worker/memory/dao/MemoryMetricH2DAO.java b/apm-collector/apm-collector-agentjvm/src/main/java/org/skywalking/apm/collector/agentjvm/worker/memory/dao/MemoryMetricH2DAO.java index 33e80d674..3d6fb0d4d 100644 --- a/apm-collector/apm-collector-agentjvm/src/main/java/org/skywalking/apm/collector/agentjvm/worker/memory/dao/MemoryMetricH2DAO.java +++ b/apm-collector/apm-collector-agentjvm/src/main/java/org/skywalking/apm/collector/agentjvm/worker/memory/dao/MemoryMetricH2DAO.java @@ -18,16 +18,17 @@ package org.skywalking.apm.collector.agentjvm.worker.memory.dao; +import java.util.HashMap; +import java.util.Map; + import org.skywalking.apm.collector.core.stream.Data; import org.skywalking.apm.collector.storage.define.DataDefine; import org.skywalking.apm.collector.storage.define.jvm.MemoryMetricTable; +import org.skywalking.apm.collector.storage.h2.SqlBuilder; 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 java.util.HashMap; -import java.util.Map; - /** * @author pengys5, clevertension */ @@ -48,7 +49,7 @@ public class MemoryMetricH2DAO extends H2DAO implements IMemoryMetricDAO, IPersi source.put(MemoryMetricTable.COLUMN_COMMITTED, data.getDataLong(3)); source.put(MemoryMetricTable.COLUMN_TIME_BUCKET, data.getDataLong(4)); - String sql = getBatchInsertSql(MemoryMetricTable.TABLE, source.keySet()); + String sql = SqlBuilder.buildBatchInsertSql(MemoryMetricTable.TABLE, source.keySet()); entity.setSql(sql); entity.setParams(source.values().toArray(new Object[0])); return entity; diff --git a/apm-collector/apm-collector-agentjvm/src/main/java/org/skywalking/apm/collector/agentjvm/worker/memorypool/dao/MemoryPoolMetricH2DAO.java b/apm-collector/apm-collector-agentjvm/src/main/java/org/skywalking/apm/collector/agentjvm/worker/memorypool/dao/MemoryPoolMetricH2DAO.java index ad94e8a39..8ecfe5ab5 100644 --- a/apm-collector/apm-collector-agentjvm/src/main/java/org/skywalking/apm/collector/agentjvm/worker/memorypool/dao/MemoryPoolMetricH2DAO.java +++ b/apm-collector/apm-collector-agentjvm/src/main/java/org/skywalking/apm/collector/agentjvm/worker/memorypool/dao/MemoryPoolMetricH2DAO.java @@ -18,16 +18,17 @@ package org.skywalking.apm.collector.agentjvm.worker.memorypool.dao; +import java.util.HashMap; +import java.util.Map; + import org.skywalking.apm.collector.core.stream.Data; import org.skywalking.apm.collector.storage.define.DataDefine; import org.skywalking.apm.collector.storage.define.jvm.MemoryPoolMetricTable; +import org.skywalking.apm.collector.storage.h2.SqlBuilder; 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 java.util.HashMap; -import java.util.Map; - /** * @author pengys5, clevertension */ @@ -48,7 +49,7 @@ public class MemoryPoolMetricH2DAO extends H2DAO implements IMemoryPoolMetricDAO source.put(MemoryPoolMetricTable.COLUMN_COMMITTED, data.getDataLong(3)); source.put(MemoryPoolMetricTable.COLUMN_TIME_BUCKET, data.getDataLong(4)); - String sql = getBatchInsertSql(MemoryPoolMetricTable.TABLE, source.keySet()); + String sql = SqlBuilder.buildBatchInsertSql(MemoryPoolMetricTable.TABLE, source.keySet()); entity.setSql(sql); entity.setParams(source.values().toArray(new Object[0])); return entity; 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 dcf6b8e4c..fdb6c963b 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 @@ -19,12 +19,11 @@ package org.skywalking.apm.collector.agentregister.worker.application.dao; -import java.text.MessageFormat; - import org.skywalking.apm.collector.client.h2.H2Client; import org.skywalking.apm.collector.client.h2.H2ClientException; import org.skywalking.apm.collector.storage.define.register.ApplicationDataDefine; import org.skywalking.apm.collector.storage.define.register.ApplicationTable; +import org.skywalking.apm.collector.storage.h2.SqlBuilder; import org.skywalking.apm.collector.storage.h2.dao.H2DAO; import org.slf4j.Logger; import org.slf4j.LoggerFactory; @@ -57,7 +56,7 @@ public class ApplicationH2DAO extends H2DAO implements IApplicationDAO { @Override public void save(ApplicationDataDefine.Application application) { H2Client client = getClient(); - String sql = MessageFormat.format(INSERT_APPLICATION_SQL, ApplicationTable.TABLE, ApplicationTable.COLUMN_APPLICATION_ID, + String sql = SqlBuilder.buildSql(INSERT_APPLICATION_SQL, ApplicationTable.TABLE, ApplicationTable.COLUMN_APPLICATION_ID, ApplicationTable.COLUMN_APPLICATION_CODE); Object[] params = new Object[] {application.getApplicationId(), application.getApplicationCode()}; try { 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 a3f254d97..39a352d4f 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 @@ -20,7 +20,6 @@ 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; @@ -28,6 +27,7 @@ import org.skywalking.apm.collector.client.h2.H2Client; import org.skywalking.apm.collector.client.h2.H2ClientException; 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.SqlBuilder; import org.skywalking.apm.collector.storage.h2.dao.H2DAO; import org.slf4j.Logger; import org.slf4j.LoggerFactory; @@ -43,7 +43,7 @@ public class InstanceH2DAO extends H2DAO implements IInstanceDAO { @Override public int getInstanceId(int applicationId, String agentUUID) { logger.info("get the application id with application id = {}, agentUUID = {}", applicationId, agentUUID); H2Client client = getClient(); - String sql = MessageFormat.format(GET_INSTANCE_ID_SQL, InstanceTable.COLUMN_INSTANCE_ID, InstanceTable.TABLE, InstanceTable.COLUMN_APPLICATION_ID, + String sql = SqlBuilder.buildSql(GET_INSTANCE_ID_SQL, InstanceTable.COLUMN_INSTANCE_ID, InstanceTable.TABLE, InstanceTable.COLUMN_APPLICATION_ID, InstanceTable.COLUMN_AGENT_UUID); Object[] params = new Object[]{applicationId, agentUUID}; try (ResultSet rs = client.executeQuery(sql, params)) { @@ -73,7 +73,7 @@ public class InstanceH2DAO extends H2DAO implements IInstanceDAO { source.put(InstanceTable.COLUMN_REGISTER_TIME, instance.getRegisterTime()); source.put(InstanceTable.COLUMN_HEARTBEAT_TIME, instance.getHeartBeatTime()); source.put(InstanceTable.COLUMN_OS_INFO, instance.getOsInfo()); - String sql = getBatchInsertSql(InstanceTable.TABLE, source.keySet()); + String sql = SqlBuilder.buildBatchInsertSql(InstanceTable.TABLE, source.keySet()); Object[] params = source.values().toArray(new Object[0]); try { client.execute(sql, params); @@ -84,7 +84,7 @@ public class InstanceH2DAO extends H2DAO implements IInstanceDAO { @Override public void updateHeartbeatTime(int instanceId, long heartbeatTime) { H2Client client = getClient(); - String sql = MessageFormat.format(UPDATE_HEARTBEAT_TIME_SQL, InstanceTable.TABLE, InstanceTable.COLUMN_HEARTBEAT_TIME, + String sql = SqlBuilder.buildSql(UPDATE_HEARTBEAT_TIME_SQL, InstanceTable.TABLE, InstanceTable.COLUMN_HEARTBEAT_TIME, InstanceTable.COLUMN_INSTANCE_ID); Object[] params = new Object[] {heartbeatTime, instanceId}; try { @@ -97,7 +97,7 @@ public class InstanceH2DAO extends H2DAO implements IInstanceDAO { @Override public int getApplicationId(int applicationInstanceId) { logger.info("get the application id with application id = {}", applicationInstanceId); H2Client client = getClient(); - String sql = MessageFormat.format(GET_APPLICATION_ID_SQL, InstanceTable.COLUMN_APPLICATION_ID, InstanceTable.TABLE, InstanceTable.COLUMN_APPLICATION_ID); + String sql = SqlBuilder.buildSql(GET_APPLICATION_ID_SQL, InstanceTable.COLUMN_APPLICATION_ID, InstanceTable.TABLE, InstanceTable.COLUMN_APPLICATION_ID); Object[] params = new Object[]{applicationInstanceId}; try (ResultSet rs = client.executeQuery(sql, params)) { if (rs.next()) { diff --git a/apm-collector/apm-collector-agentregister/src/main/java/org/skywalking/apm/collector/agentregister/worker/servicename/dao/ServiceNameH2DAO.java b/apm-collector/apm-collector-agentregister/src/main/java/org/skywalking/apm/collector/agentregister/worker/servicename/dao/ServiceNameH2DAO.java index 991011069..df85fcc20 100644 --- a/apm-collector/apm-collector-agentregister/src/main/java/org/skywalking/apm/collector/agentregister/worker/servicename/dao/ServiceNameH2DAO.java +++ b/apm-collector/apm-collector-agentregister/src/main/java/org/skywalking/apm/collector/agentregister/worker/servicename/dao/ServiceNameH2DAO.java @@ -18,21 +18,21 @@ package org.skywalking.apm.collector.agentregister.worker.servicename.dao; +import java.sql.ResultSet; +import java.sql.SQLException; +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.util.Const; import org.skywalking.apm.collector.storage.define.register.ServiceNameDataDefine; import org.skywalking.apm.collector.storage.define.register.ServiceNameTable; +import org.skywalking.apm.collector.storage.h2.SqlBuilder; 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, clevertension */ @@ -44,7 +44,7 @@ public class ServiceNameH2DAO extends H2DAO implements IServiceNameDAO { @Override public int getServiceId(int applicationId, String serviceName) { H2Client client = getClient(); - String sql = MessageFormat.format(GET_SERVICE_ID_SQL, ServiceNameTable.COLUMN_SERVICE_ID, + String sql = SqlBuilder.buildSql(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)) { @@ -71,7 +71,7 @@ public class ServiceNameH2DAO extends H2DAO implements IServiceNameDAO { @Override public String getServiceName(int serviceId) { H2Client client = getClient(); - String sql = MessageFormat.format(GET_SERVICE_NAME_SQL, ServiceNameTable.COLUMN_SERVICE_NAME, + String sql = SqlBuilder.buildSql(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)) { @@ -93,7 +93,7 @@ public class ServiceNameH2DAO extends H2DAO implements IServiceNameDAO { source.put(ServiceNameTable.COLUMN_APPLICATION_ID, serviceName.getApplicationId()); source.put(ServiceNameTable.COLUMN_SERVICE_NAME, serviceName.getServiceName()); - String sql = getBatchInsertSql(ServiceNameTable.TABLE, source.keySet()); + String sql = SqlBuilder.buildBatchInsertSql(ServiceNameTable.TABLE, source.keySet()); Object[] params = source.values().toArray(new Object[0]); try { client.execute(sql, params); diff --git a/apm-collector/apm-collector-agentstream/src/main/java/org/skywalking/apm/collector/agentstream/worker/global/dao/GlobalTraceH2DAO.java b/apm-collector/apm-collector-agentstream/src/main/java/org/skywalking/apm/collector/agentstream/worker/global/dao/GlobalTraceH2DAO.java index c79185b5f..24cc79424 100644 --- a/apm-collector/apm-collector-agentstream/src/main/java/org/skywalking/apm/collector/agentstream/worker/global/dao/GlobalTraceH2DAO.java +++ b/apm-collector/apm-collector-agentstream/src/main/java/org/skywalking/apm/collector/agentstream/worker/global/dao/GlobalTraceH2DAO.java @@ -22,6 +22,7 @@ import org.skywalking.apm.collector.core.framework.UnexpectedException; import org.skywalking.apm.collector.core.stream.Data; import org.skywalking.apm.collector.storage.define.DataDefine; import org.skywalking.apm.collector.storage.define.global.GlobalTraceTable; +import org.skywalking.apm.collector.storage.h2.SqlBuilder; 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; @@ -53,7 +54,7 @@ public class GlobalTraceH2DAO extends H2DAO implements IGlobalTraceDAO, IPersist source.put(GlobalTraceTable.COLUMN_TIME_BUCKET, data.getDataLong(0)); logger.debug("global trace source: {}", source.toString()); - String sql = getBatchInsertSql(GlobalTraceTable.TABLE, source.keySet()); + String sql = SqlBuilder.buildBatchInsertSql(GlobalTraceTable.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/instance/performance/dao/InstPerformanceH2DAO.java b/apm-collector/apm-collector-agentstream/src/main/java/org/skywalking/apm/collector/agentstream/worker/instance/performance/dao/InstPerformanceH2DAO.java index 14eba85ff..578da83d2 100644 --- a/apm-collector/apm-collector-agentstream/src/main/java/org/skywalking/apm/collector/agentstream/worker/instance/performance/dao/InstPerformanceH2DAO.java +++ b/apm-collector/apm-collector-agentstream/src/main/java/org/skywalking/apm/collector/agentstream/worker/instance/performance/dao/InstPerformanceH2DAO.java @@ -18,22 +18,25 @@ package org.skywalking.apm.collector.agentstream.worker.instance.performance.dao; +import java.sql.ResultSet; +import java.sql.SQLException; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +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.DataDefine; import org.skywalking.apm.collector.storage.define.instance.InstPerformanceTable; +import org.skywalking.apm.collector.storage.h2.SqlBuilder; 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.*; - /** * @author pengys5, clevertension */ @@ -42,7 +45,7 @@ public class InstPerformanceH2DAO extends H2DAO implements IInstPerformanceDAO, 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, InstPerformanceTable.TABLE, "id"); + String sql = SqlBuilder.buildSql(GET_SQL, InstPerformanceTable.TABLE, "id"); Object[] params = new Object[]{id}; try (ResultSet rs = client.executeQuery(sql, params)) { if (rs.next()) { @@ -68,7 +71,7 @@ public class InstPerformanceH2DAO extends H2DAO implements IInstPerformanceDAO, source.put(InstPerformanceTable.COLUMN_CALLS, data.getDataInteger(2)); source.put(InstPerformanceTable.COLUMN_COST_TOTAL, data.getDataLong(0)); source.put(InstPerformanceTable.COLUMN_TIME_BUCKET, data.getDataLong(1)); - String sql = getBatchInsertSql(InstPerformanceTable.TABLE, source.keySet()); + String sql = SqlBuilder.buildBatchInsertSql(InstPerformanceTable.TABLE, source.keySet()); entity.setSql(sql); entity.setParams(source.values().toArray(new Object[0])); return entity; @@ -82,7 +85,7 @@ public class InstPerformanceH2DAO extends H2DAO implements IInstPerformanceDAO, source.put(InstPerformanceTable.COLUMN_COST_TOTAL, data.getDataLong(0)); source.put(InstPerformanceTable.COLUMN_TIME_BUCKET, data.getDataLong(1)); String id = data.getDataString(0); - String sql = getBatchUpdateSql(InstPerformanceTable.TABLE, source.keySet(), "id"); + String sql = SqlBuilder.buildBatchUpdateSql(InstPerformanceTable.TABLE, source.keySet(), "id"); entity.setSql(sql); List values = new ArrayList<>(source.values()); values.add(id); diff --git a/apm-collector/apm-collector-agentstream/src/main/java/org/skywalking/apm/collector/agentstream/worker/node/component/dao/NodeComponentH2DAO.java b/apm-collector/apm-collector-agentstream/src/main/java/org/skywalking/apm/collector/agentstream/worker/node/component/dao/NodeComponentH2DAO.java index 2eec8d55e..e44b263df 100644 --- a/apm-collector/apm-collector-agentstream/src/main/java/org/skywalking/apm/collector/agentstream/worker/node/component/dao/NodeComponentH2DAO.java +++ b/apm-collector/apm-collector-agentstream/src/main/java/org/skywalking/apm/collector/agentstream/worker/node/component/dao/NodeComponentH2DAO.java @@ -18,23 +18,26 @@ package org.skywalking.apm.collector.agentstream.worker.node.component.dao; +import java.sql.ResultSet; +import java.sql.SQLException; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +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.DataDefine; import org.skywalking.apm.collector.storage.define.node.NodeComponentTable; import org.skywalking.apm.collector.storage.define.serviceref.ServiceReferenceTable; +import org.skywalking.apm.collector.storage.h2.SqlBuilder; 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.*; - /** * @author pengys5, clevertension */ @@ -45,7 +48,7 @@ public class NodeComponentH2DAO extends H2DAO implements INodeComponentDAO, IPer @Override public Data get(String id, DataDefine dataDefine) { H2Client client = getClient(); - String sql = MessageFormat.format(GET_SQL, ServiceReferenceTable.TABLE, "id"); + String sql = SqlBuilder.buildSql(GET_SQL, ServiceReferenceTable.TABLE, "id"); Object[] params = new Object[]{id}; try (ResultSet rs = client.executeQuery(sql, params)) { if (rs.next()) { @@ -74,7 +77,7 @@ public class NodeComponentH2DAO extends H2DAO implements INodeComponentDAO, IPer source.put(NodeComponentTable.COLUMN_PEER, data.getDataString(2)); source.put(NodeComponentTable.COLUMN_TIME_BUCKET, data.getDataLong(0)); - String sql = getBatchInsertSql(NodeComponentTable.TABLE, source.keySet()); + String sql = SqlBuilder.buildBatchInsertSql(NodeComponentTable.TABLE, source.keySet()); entity.setSql(sql); entity.setParams(source.values().toArray(new Object[0])); return entity; @@ -90,7 +93,7 @@ public class NodeComponentH2DAO extends H2DAO implements INodeComponentDAO, IPer source.put(NodeComponentTable.COLUMN_PEER, data.getDataString(2)); source.put(NodeComponentTable.COLUMN_TIME_BUCKET, data.getDataLong(0)); String id = data.getDataString(0); - String sql = getBatchUpdateSql(NodeComponentTable.TABLE, source.keySet(), "id"); + String sql = SqlBuilder.buildBatchUpdateSql(NodeComponentTable.TABLE, source.keySet(), "id"); entity.setSql(sql); List values = new ArrayList<>(source.values()); values.add(id); 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 7a515cec3..3805ad9af 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 @@ -18,23 +18,26 @@ package org.skywalking.apm.collector.agentstream.worker.node.mapping.dao; +import java.sql.ResultSet; +import java.sql.SQLException; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; + import org.skywalking.apm.collector.agentstream.worker.node.component.dao.NodeComponentH2DAO; 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.h2.SqlBuilder; 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.*; - /** * @author pengys5, clevertension */ @@ -43,7 +46,7 @@ public class NodeMappingH2DAO extends H2DAO implements INodeMappingDAO, IPersist 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, NodeMappingTable.TABLE, "id"); + String sql = SqlBuilder.buildSql(GET_SQL, NodeMappingTable.TABLE, "id"); Object[] params = new Object[]{id}; try (ResultSet rs = client.executeQuery(sql, params)) { if (rs.next()) { @@ -67,7 +70,7 @@ public class NodeMappingH2DAO extends H2DAO implements INodeMappingDAO, IPersist source.put(NodeMappingTable.COLUMN_ADDRESS_ID, data.getDataInteger(1)); source.put(NodeMappingTable.COLUMN_ADDRESS, data.getDataString(1)); source.put(NodeMappingTable.COLUMN_TIME_BUCKET, data.getDataLong(0)); - String sql = getBatchInsertSql(NodeMappingTable.TABLE, source.keySet()); + String sql = SqlBuilder.buildBatchInsertSql(NodeMappingTable.TABLE, source.keySet()); entity.setSql(sql); entity.setParams(source.values().toArray(new Object[0])); @@ -81,7 +84,7 @@ public class NodeMappingH2DAO extends H2DAO implements INodeMappingDAO, IPersist source.put(NodeMappingTable.COLUMN_ADDRESS, data.getDataString(1)); source.put(NodeMappingTable.COLUMN_TIME_BUCKET, data.getDataLong(0)); String id = data.getDataString(0); - String sql = getBatchUpdateSql(NodeMappingTable.TABLE, source.keySet(), "id"); + String sql = SqlBuilder.buildBatchUpdateSql(NodeMappingTable.TABLE, source.keySet(), "id"); entity.setSql(sql); List values = new ArrayList<>(source.values()); values.add(id); 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 c00701451..da6957b9f 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 @@ -18,25 +18,25 @@ package org.skywalking.apm.collector.agentstream.worker.noderef.dao; +import java.sql.ResultSet; +import java.sql.SQLException; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +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.DataDefine; import org.skywalking.apm.collector.storage.define.noderef.NodeReferenceTable; +import org.skywalking.apm.collector.storage.h2.SqlBuilder; 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, clevertension */ @@ -45,7 +45,7 @@ public class NodeReferenceH2DAO extends H2DAO implements INodeReferenceDAO, IPer 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"); + String sql = SqlBuilder.buildSql(GET_SQL, NodeReferenceTable.TABLE, "id"); Object[] params = new Object[]{id}; try (ResultSet rs = client.executeQuery(sql, params)) { if (rs.next()) { @@ -81,7 +81,7 @@ public class NodeReferenceH2DAO extends H2DAO implements INodeReferenceDAO, IPer 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(NodeReferenceTable.TABLE, source.keySet()); + String sql = SqlBuilder.buildBatchInsertSql(NodeReferenceTable.TABLE, source.keySet()); entity.setSql(sql); entity.setParams(source.values().toArray(new Object[0])); @@ -101,7 +101,7 @@ public class NodeReferenceH2DAO extends H2DAO implements INodeReferenceDAO, IPer 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(NodeReferenceTable.TABLE, source.keySet(), "id"); + String sql = SqlBuilder.buildBatchUpdateSql(NodeReferenceTable.TABLE, source.keySet(), "id"); entity.setSql(sql); List values = new ArrayList<>(source.values()); values.add(id); diff --git a/apm-collector/apm-collector-agentstream/src/main/java/org/skywalking/apm/collector/agentstream/worker/segment/cost/dao/SegmentCostH2DAO.java b/apm-collector/apm-collector-agentstream/src/main/java/org/skywalking/apm/collector/agentstream/worker/segment/cost/dao/SegmentCostH2DAO.java index 2c11a9c81..a8b30c3c4 100644 --- a/apm-collector/apm-collector-agentstream/src/main/java/org/skywalking/apm/collector/agentstream/worker/segment/cost/dao/SegmentCostH2DAO.java +++ b/apm-collector/apm-collector-agentstream/src/main/java/org/skywalking/apm/collector/agentstream/worker/segment/cost/dao/SegmentCostH2DAO.java @@ -21,6 +21,7 @@ package org.skywalking.apm.collector.agentstream.worker.segment.cost.dao; import org.skywalking.apm.collector.core.stream.Data; import org.skywalking.apm.collector.storage.define.DataDefine; import org.skywalking.apm.collector.storage.define.segment.SegmentCostTable; +import org.skywalking.apm.collector.storage.h2.SqlBuilder; 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; @@ -53,7 +54,7 @@ public class SegmentCostH2DAO extends H2DAO implements ISegmentCostDAO, IPersist source.put(SegmentCostTable.COLUMN_TIME_BUCKET, data.getDataLong(3)); logger.debug("segment cost source: {}", source.toString()); - String sql = getBatchInsertSql(SegmentCostTable.TABLE, source.keySet()); + String sql = SqlBuilder.buildBatchInsertSql(SegmentCostTable.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/segment/origin/dao/SegmentH2DAO.java b/apm-collector/apm-collector-agentstream/src/main/java/org/skywalking/apm/collector/agentstream/worker/segment/origin/dao/SegmentH2DAO.java index 1b0761949..8a1ead97b 100644 --- a/apm-collector/apm-collector-agentstream/src/main/java/org/skywalking/apm/collector/agentstream/worker/segment/origin/dao/SegmentH2DAO.java +++ b/apm-collector/apm-collector-agentstream/src/main/java/org/skywalking/apm/collector/agentstream/worker/segment/origin/dao/SegmentH2DAO.java @@ -18,20 +18,21 @@ package org.skywalking.apm.collector.agentstream.worker.segment.origin.dao; +import java.util.Base64; +import java.util.HashMap; +import java.util.Map; + import org.skywalking.apm.collector.agentstream.worker.segment.cost.dao.SegmentCostH2DAO; import org.skywalking.apm.collector.core.stream.Data; import org.skywalking.apm.collector.storage.define.DataDefine; import org.skywalking.apm.collector.storage.define.segment.SegmentTable; +import org.skywalking.apm.collector.storage.h2.SqlBuilder; 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.util.Base64; -import java.util.HashMap; -import java.util.Map; - /** * @author pengys5, clevertension */ @@ -47,7 +48,7 @@ public class SegmentH2DAO extends H2DAO implements ISegmentDAO, IPersistenceDAO< source.put(SegmentTable.COLUMN_DATA_BINARY, Base64.getEncoder().encode(data.getDataBytes(0))); logger.debug("segment source: {}", source.toString()); - String sql = getBatchInsertSql(SegmentTable.TABLE, source.keySet()); + String sql = SqlBuilder.buildBatchInsertSql(SegmentTable.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/service/entry/dao/ServiceEntryH2DAO.java b/apm-collector/apm-collector-agentstream/src/main/java/org/skywalking/apm/collector/agentstream/worker/service/entry/dao/ServiceEntryH2DAO.java index d13890936..6f91ba64c 100644 --- a/apm-collector/apm-collector-agentstream/src/main/java/org/skywalking/apm/collector/agentstream/worker/service/entry/dao/ServiceEntryH2DAO.java +++ b/apm-collector/apm-collector-agentstream/src/main/java/org/skywalking/apm/collector/agentstream/worker/service/entry/dao/ServiceEntryH2DAO.java @@ -18,17 +18,6 @@ package org.skywalking.apm.collector.agentstream.worker.service.entry.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.service.ServiceEntryTable; -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.util.ArrayList; @@ -36,14 +25,27 @@ import java.util.HashMap; import java.util.List; 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.DataDefine; +import org.skywalking.apm.collector.storage.define.service.ServiceEntryTable; +import org.skywalking.apm.collector.storage.h2.SqlBuilder; +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; + /** * @author pengys5, clevertension */ public class ServiceEntryH2DAO extends H2DAO implements IServiceEntryDAO, IPersistenceDAO { private final Logger logger = LoggerFactory.getLogger(ServiceEntryH2DAO.class); + private static final String GET_SERIVCE_ENTRY_SQL = "select * from {0} where {1} = ?"; @Override public Data get(String id, DataDefine dataDefine) { H2Client client = getClient(); - String sql = "select * from " + ServiceEntryTable.TABLE + " where id = ?"; + String sql = SqlBuilder.buildSql(ServiceEntryTable.TABLE, "id"); Object[] params = new Object[] {id}; try (ResultSet rs = client.executeQuery(sql, params)) { if (rs.next()) { @@ -69,7 +71,7 @@ public class ServiceEntryH2DAO extends H2DAO implements IServiceEntryDAO, IPersi source.put(ServiceEntryTable.COLUMN_ENTRY_SERVICE_NAME, data.getDataString(1)); source.put(ServiceEntryTable.COLUMN_REGISTER_TIME, data.getDataLong(0)); source.put(ServiceEntryTable.COLUMN_NEWEST_TIME, data.getDataLong(1)); - String sql = getBatchInsertSql(ServiceEntryTable.TABLE, source.keySet()); + String sql = SqlBuilder.buildBatchInsertSql(ServiceEntryTable.TABLE, source.keySet()); entity.setSql(sql); entity.setParams(source.values().toArray(new Object[0])); return entity; @@ -83,7 +85,7 @@ public class ServiceEntryH2DAO extends H2DAO implements IServiceEntryDAO, IPersi source.put(ServiceEntryTable.COLUMN_REGISTER_TIME, data.getDataLong(0)); source.put(ServiceEntryTable.COLUMN_NEWEST_TIME, data.getDataLong(1)); String id = data.getDataString(0); - String sql = getBatchUpdateSql(ServiceEntryTable.TABLE, source.keySet(), "id"); + String sql = SqlBuilder.buildBatchUpdateSql(ServiceEntryTable.TABLE, source.keySet(), "id"); entity.setSql(sql); List values = new ArrayList<>(source.values()); values.add(id); diff --git a/apm-collector/apm-collector-agentstream/src/main/java/org/skywalking/apm/collector/agentstream/worker/serviceref/dao/ServiceReferenceH2DAO.java b/apm-collector/apm-collector-agentstream/src/main/java/org/skywalking/apm/collector/agentstream/worker/serviceref/dao/ServiceReferenceH2DAO.java index 8d8d62fe7..f649c7cae 100644 --- a/apm-collector/apm-collector-agentstream/src/main/java/org/skywalking/apm/collector/agentstream/worker/serviceref/dao/ServiceReferenceH2DAO.java +++ b/apm-collector/apm-collector-agentstream/src/main/java/org/skywalking/apm/collector/agentstream/worker/serviceref/dao/ServiceReferenceH2DAO.java @@ -20,7 +20,6 @@ package org.skywalking.apm.collector.agentstream.worker.serviceref.dao; import java.sql.ResultSet; import java.sql.SQLException; -import java.text.MessageFormat; import java.util.ArrayList; import java.util.HashMap; import java.util.List; @@ -31,6 +30,7 @@ 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.serviceref.ServiceReferenceTable; +import org.skywalking.apm.collector.storage.h2.SqlBuilder; 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; @@ -46,7 +46,7 @@ public class ServiceReferenceH2DAO extends H2DAO implements IServiceReferenceDAO @Override public Data get(String id, DataDefine dataDefine) { H2Client client = getClient(); - String sql = MessageFormat.format(GET_SQL, ServiceReferenceTable.TABLE, "id"); + String sql = SqlBuilder.buildSql(GET_SQL, ServiceReferenceTable.TABLE, "id"); Object[] params = new Object[]{id}; try (ResultSet rs = client.executeQuery(sql, params)) { if (rs.next()) { @@ -93,7 +93,7 @@ public class ServiceReferenceH2DAO extends H2DAO implements IServiceReferenceDAO source.put(ServiceReferenceTable.COLUMN_COST_SUMMARY, data.getDataLong(6)); source.put(ServiceReferenceTable.COLUMN_TIME_BUCKET, data.getDataLong(7)); - String sql = getBatchInsertSql(ServiceReferenceTable.TABLE, source.keySet()); + String sql = SqlBuilder.buildBatchInsertSql(ServiceReferenceTable.TABLE, source.keySet()); entity.setSql(sql); entity.setParams(source.values().toArray(new Object[0])); return entity; @@ -119,7 +119,7 @@ public class ServiceReferenceH2DAO extends H2DAO implements IServiceReferenceDAO source.put(ServiceReferenceTable.COLUMN_TIME_BUCKET, data.getDataLong(7)); String id = data.getDataString(0); - String sql = getBatchUpdateSql(ServiceReferenceTable.TABLE, source.keySet(), "id"); + String sql = SqlBuilder.buildBatchUpdateSql(ServiceReferenceTable.TABLE, source.keySet(), "id"); entity.setSql(sql); List values = new ArrayList<>(source.values()); values.add(id); diff --git a/apm-collector/apm-collector-storage/src/main/java/org/skywalking/apm/collector/storage/h2/SqlBuilder.java b/apm-collector/apm-collector-storage/src/main/java/org/skywalking/apm/collector/storage/h2/SqlBuilder.java new file mode 100644 index 000000000..f3944030c --- /dev/null +++ b/apm-collector/apm-collector-storage/src/main/java/org/skywalking/apm/collector/storage/h2/SqlBuilder.java @@ -0,0 +1,61 @@ +/* + * Copyright 2017, OpenSkywalking Organization All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + * Project repository: https://github.com/OpenSkywalking/skywalking + */ + +package org.skywalking.apm.collector.storage.h2; + +import java.text.MessageFormat; +import java.util.List; +import java.util.Set; + +public class SqlBuilder { + public static final String buildSql(String sql, Object ... args) { + return MessageFormat.format(sql, args); + } + + public static final String buildSql(String sql, List args) { + MessageFormat messageFormat = new MessageFormat(sql); + return messageFormat.format(args.toArray(new Object[0])); + } + + public static final String buildBatchInsertSql(String tableName, Set columnNames) { + StringBuilder sb = new StringBuilder("insert into "); + sb.append(tableName).append("("); + columnNames.forEach((columnName) -> { + sb.append(columnName).append(","); + }); + sb.delete(sb.length() - 1, sb.length()); + sb.append(") values("); + for (int i = 0; i < columnNames.size(); i++) { + sb.append("?,"); + } + sb.delete(sb.length() - 1, sb.length()); + sb.append(")"); + return sb.toString(); + } + + public static final String buildBatchUpdateSql(String tableName, Set columnNames, String whereClauseName) { + StringBuilder sb = new StringBuilder("update "); + sb.append(tableName).append(" set "); + columnNames.forEach((columnName) -> { + sb.append(columnName).append("=?,"); + }); + sb.delete(sb.length() - 1, sb.length()); + sb.append(" where ").append(whereClauseName).append("=?"); + return sb.toString(); + } +} diff --git a/apm-collector/apm-collector-storage/src/main/java/org/skywalking/apm/collector/storage/h2/dao/H2DAO.java b/apm-collector/apm-collector-storage/src/main/java/org/skywalking/apm/collector/storage/h2/dao/H2DAO.java index 8d867d2fc..39dbc78e0 100644 --- a/apm-collector/apm-collector-storage/src/main/java/org/skywalking/apm/collector/storage/h2/dao/H2DAO.java +++ b/apm-collector/apm-collector-storage/src/main/java/org/skywalking/apm/collector/storage/h2/dao/H2DAO.java @@ -18,16 +18,15 @@ package org.skywalking.apm.collector.storage.h2.dao; +import java.sql.ResultSet; +import java.sql.SQLException; + import org.skywalking.apm.collector.client.h2.H2Client; import org.skywalking.apm.collector.client.h2.H2ClientException; import org.skywalking.apm.collector.storage.dao.DAO; import org.slf4j.Logger; import org.slf4j.LoggerFactory; -import java.sql.ResultSet; -import java.sql.SQLException; -import java.util.Set; - /** * @author pengys5 */ @@ -60,30 +59,4 @@ public abstract class H2DAO extends DAO { return 0; } - public final String getBatchInsertSql(String tableName, Set columnNames) { - StringBuilder sb = new StringBuilder("insert into "); - sb.append(tableName).append("("); - columnNames.forEach((columnName) -> { - sb.append(columnName).append(","); - }); - sb.delete(sb.length() - 1, sb.length()); - sb.append(") values("); - for (int i = 0; i < columnNames.size(); i++) { - sb.append("?,"); - } - sb.delete(sb.length() - 1, sb.length()); - sb.append(")"); - return sb.toString(); - } - - public final String getBatchUpdateSql(String tableName, Set columnNames, String whereClauseName) { - StringBuilder sb = new StringBuilder("update "); - sb.append(tableName).append(" set "); - columnNames.forEach((columnName) -> { - sb.append(columnName).append("=?,"); - }); - sb.delete(sb.length() - 1, sb.length()); - sb.append(" where ").append(whereClauseName).append("=?"); - return sb.toString(); - } } 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 1402a33aa..4a79f2f3f 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 @@ -18,18 +18,18 @@ package org.skywalking.apm.collector.ui.dao; +import java.sql.ResultSet; +import java.sql.SQLException; + 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.ApplicationTable; +import org.skywalking.apm.collector.storage.h2.SqlBuilder; 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, clevertension */ @@ -40,7 +40,7 @@ public class ApplicationH2DAO extends H2DAO implements IApplicationDAO { @Override public String getApplicationCode(int applicationId) { logger.debug("get application code, applicationId: {}", applicationId); H2Client client = getClient(); - String sql = MessageFormat.format(GET_APPLICATION_CODE_SQL, ApplicationTable.COLUMN_APPLICATION_CODE, ApplicationTable.TABLE, ApplicationTable.COLUMN_APPLICATION_ID); + String sql = SqlBuilder.buildSql(GET_APPLICATION_CODE_SQL, ApplicationTable.COLUMN_APPLICATION_CODE, ApplicationTable.TABLE, ApplicationTable.COLUMN_APPLICATION_ID); Object[] params = new Object[]{applicationId}; 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/CpuMetricH2DAO.java b/apm-collector/apm-collector-ui/src/main/java/org/skywalking/apm/collector/ui/dao/CpuMetricH2DAO.java index ec7d86026..8d6d302ba 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 @@ -18,21 +18,22 @@ package org.skywalking.apm.collector.ui.dao; -import com.google.gson.JsonArray; +import java.sql.ResultSet; +import java.sql.SQLException; +import java.util.ArrayList; +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.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.h2.SqlBuilder; 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; +import com.google.gson.JsonArray; /** * @author pengys5, clevertension @@ -44,7 +45,7 @@ public class CpuMetricH2DAO extends H2DAO implements ICpuMetricDAO { @Override public int getMetric(int instanceId, long timeBucket) { String id = timeBucket + Const.ID_SPLIT + instanceId; H2Client client = getClient(); - String sql = MessageFormat.format(GET_CPU_METRIC_SQL, CpuMetricTable.TABLE, "id"); + String sql = SqlBuilder.buildSql(GET_CPU_METRIC_SQL, CpuMetricTable.TABLE, "id"); Object[] params = new Object[]{id}; try (ResultSet rs = client.executeQuery(sql, params)) { if (rs.next()) { @@ -58,7 +59,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_CPU_METRICS_SQL, CpuMetricTable.TABLE, "id"); + String sql = SqlBuilder.buildSql(GET_CPU_METRICS_SQL, CpuMetricTable.TABLE, "id"); long timeBucket = startTimeBucket; List idList = new ArrayList<>(); 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 2cd8f5031..be97ac1e0 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 @@ -18,23 +18,24 @@ package org.skywalking.apm.collector.ui.dao; -import com.google.gson.JsonArray; -import com.google.gson.JsonObject; +import java.sql.ResultSet; +import java.sql.SQLException; +import java.util.ArrayList; +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.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.SqlBuilder; 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; +import com.google.gson.JsonArray; +import com.google.gson.JsonObject; /** * @author pengys5, clevertension @@ -55,7 +56,7 @@ public class GCMetricH2DAO extends H2DAO implements IGCMetricDAO { 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, + sql = SqlBuilder.buildSql(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++) { @@ -82,7 +83,7 @@ public class GCMetricH2DAO extends H2DAO implements IGCMetricDAO { @Override public JsonObject getMetric(int instanceId, long timeBucket) { JsonObject response = new JsonObject(); H2Client client = getClient(); - String sql = MessageFormat.format(GET_GC_METRIC_SQL, GCMetricTable.TABLE, "id"); + String sql = SqlBuilder.buildSql(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)) { @@ -108,7 +109,7 @@ public class GCMetricH2DAO extends H2DAO implements IGCMetricDAO { @Override public JsonObject getMetric(int instanceId, long startTimeBucket, long endTimeBucket) { JsonObject response = new JsonObject(); H2Client client = getClient(); - String sql = MessageFormat.format(GET_GC_METRICS_SQL, GCMetricTable.TABLE, "id"); + String sql = SqlBuilder.buildSql(GET_GC_METRICS_SQL, GCMetricTable.TABLE, "id"); long timeBucket = startTimeBucket; List idList = new ArrayList<>(); do { @@ -146,7 +147,7 @@ public class GCMetricH2DAO extends H2DAO implements IGCMetricDAO { idList1.add(oldId); } while (timeBucket <= endTimeBucket); - String sql1 = MessageFormat.format(GET_GC_METRICS_SQL, GCMetricTable.TABLE, "id"); + String sql1 = SqlBuilder.buildSql(GET_GC_METRICS_SQL, GCMetricTable.TABLE, "id"); StringBuilder builder1 = new StringBuilder(); for (int i = 0; i < idList1.size(); i++) { builder1.append("?,"); 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 705ca9067..6920d915a 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 @@ -18,19 +18,19 @@ package org.skywalking.apm.collector.ui.dao; +import java.sql.ResultSet; +import java.sql.SQLException; +import java.util.ArrayList; +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.SqlBuilder; 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, clevertension */ @@ -41,7 +41,7 @@ public class GlobalTraceH2DAO extends H2DAO implements IGlobalTraceDAO { @Override public List getGlobalTraceId(String segmentId) { List globalTraceIds = new ArrayList<>(); H2Client client = getClient(); - String sql = MessageFormat.format(GET_GLOBAL_TRACE_ID_SQL, GlobalTraceTable.COLUMN_GLOBAL_TRACE_ID, + String sql = SqlBuilder.buildSql(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)) { @@ -59,7 +59,7 @@ public class GlobalTraceH2DAO extends H2DAO implements IGlobalTraceDAO { @Override public List getSegmentIds(String globalTraceId) { List segmentIds = new ArrayList<>(); H2Client client = getClient(); - String sql = MessageFormat.format(GET_SEGMENT_IDS_SQL, GlobalTraceTable.COLUMN_SEGMENT_ID, + String sql = SqlBuilder.buildSql(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)) { 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 dcfb3953a..9cd63b828 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 @@ -18,21 +18,22 @@ package org.skywalking.apm.collector.ui.dao; -import com.google.gson.JsonArray; +import java.sql.ResultSet; +import java.sql.SQLException; +import java.util.ArrayList; +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.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.h2.SqlBuilder; 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; +import com.google.gson.JsonArray; /** * @author pengys5, clevertension @@ -45,7 +46,7 @@ public class InstPerformanceH2DAO extends H2DAO implements IInstPerformanceDAO { @Override public InstPerformance get(long[] timeBuckets, int instanceId) { H2Client client = getClient(); 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); + String sql = SqlBuilder.buildSql(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++) { builder.append("?,"); @@ -73,7 +74,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"); + String sql = SqlBuilder.buildSql(GET_TPS_METRIC_SQL, InstPerformanceTable.TABLE, "id"); Object[] params = new Object[]{instanceId}; try (ResultSet rs = client.executeQuery(sql, params)) { if (rs.next()) { @@ -88,7 +89,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"); + String sql = SqlBuilder.buildSql(GET_TPS_METRICS_SQL, InstPerformanceTable.TABLE, "id"); long timeBucket = startTimeBucket; List idList = new ArrayList<>(); @@ -122,7 +123,7 @@ public class InstPerformanceH2DAO extends H2DAO implements IInstPerformanceDAO { @Override public int getRespTimeMetric(int instanceId, long timeBucket) { H2Client client = getClient(); - String sql = MessageFormat.format(GET_TPS_METRIC_SQL, InstPerformanceTable.TABLE, "id"); + String sql = SqlBuilder.buildSql(GET_TPS_METRIC_SQL, InstPerformanceTable.TABLE, "id"); Object[] params = new Object[]{instanceId}; try (ResultSet rs = client.executeQuery(sql, params)) { if (rs.next()) { @@ -138,7 +139,7 @@ public class InstPerformanceH2DAO extends H2DAO implements IInstPerformanceDAO { @Override public JsonArray getRespTimeMetric(int instanceId, long startTimeBucket, long endTimeBucket) { H2Client client = getClient(); - String sql = MessageFormat.format(GET_TPS_METRICS_SQL, InstPerformanceTable.TABLE, "id"); + String sql = SqlBuilder.buildSql(GET_TPS_METRICS_SQL, InstPerformanceTable.TABLE, "id"); long timeBucket = startTimeBucket; List idList = new ArrayList<>(); 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 5b3b744eb..6b3c72fc0 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 @@ -18,23 +18,24 @@ package org.skywalking.apm.collector.ui.dao; -import com.google.gson.JsonArray; -import com.google.gson.JsonObject; +import java.sql.ResultSet; +import java.sql.SQLException; +import java.util.LinkedList; +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.core.util.TimeBucketUtils; 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.SqlBuilder; 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.LinkedList; -import java.util.List; +import com.google.gson.JsonArray; +import com.google.gson.JsonObject; /** * @author pengys5, clevertension @@ -52,7 +53,7 @@ public class InstanceH2DAO extends H2DAO implements IInstanceDAO { H2Client client = getClient(); long fiveMinuteBefore = System.currentTimeMillis() - 5 * 60 * 1000; fiveMinuteBefore = TimeBucketUtils.INSTANCE.getSecondTimeBucket(fiveMinuteBefore); - String sql = MessageFormat.format(GET_LAST_HEARTBEAT_TIME_SQL, InstanceTable.COLUMN_HEARTBEAT_TIME, InstanceTable.TABLE, InstanceTable.COLUMN_HEARTBEAT_TIME); + String sql = SqlBuilder.buildSql(GET_LAST_HEARTBEAT_TIME_SQL, InstanceTable.COLUMN_HEARTBEAT_TIME, InstanceTable.TABLE, InstanceTable.COLUMN_HEARTBEAT_TIME); Object[] params = new Object[]{fiveMinuteBefore}; try (ResultSet rs = client.executeQuery(sql, params)) { if (rs.next()) { @@ -69,7 +70,7 @@ public class InstanceH2DAO extends H2DAO implements IInstanceDAO { H2Client client = getClient(); 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, + String sql = SqlBuilder.buildSql(GET_INST_LAST_HEARTBEAT_TIME_SQL, InstanceTable.COLUMN_HEARTBEAT_TIME, InstanceTable.TABLE, InstanceTable.COLUMN_HEARTBEAT_TIME, InstanceTable.COLUMN_INSTANCE_ID); Object[] params = new Object[]{fiveMinuteBefore, applicationInstanceId}; try (ResultSet rs = client.executeQuery(sql, params)) { @@ -86,7 +87,7 @@ public class InstanceH2DAO extends H2DAO implements IInstanceDAO { public JsonArray getApplications(long startTime, long endTime) { H2Client client = getClient(); JsonArray applications = new JsonArray(); - String sql = MessageFormat.format(GET_APPLICATIONS_SQL, InstanceTable.COLUMN_INSTANCE_ID, + String sql = SqlBuilder.buildSql(GET_APPLICATIONS_SQL, InstanceTable.COLUMN_INSTANCE_ID, InstanceTable.TABLE, InstanceTable.COLUMN_HEARTBEAT_TIME, InstanceTable.COLUMN_APPLICATION_ID); Object[] params = new Object[]{startTime, endTime}; try (ResultSet rs = client.executeQuery(sql, params)) { @@ -108,7 +109,7 @@ public class InstanceH2DAO extends H2DAO implements IInstanceDAO { @Override public InstanceDataDefine.Instance getInstance(int instanceId) { H2Client client = getClient(); - String sql = MessageFormat.format(GET_INSTANCE_SQL, InstanceTable.TABLE, InstanceTable.COLUMN_INSTANCE_ID); + String sql = SqlBuilder.buildSql(GET_INSTANCE_SQL, InstanceTable.TABLE, InstanceTable.COLUMN_INSTANCE_ID); Object[] params = new Object[]{instanceId}; try (ResultSet rs = client.executeQuery(sql, params)) { if (rs.next()) { @@ -132,7 +133,7 @@ public class InstanceH2DAO extends H2DAO implements IInstanceDAO { logger.debug("get instances info, application id: {}, timeBucket: {}", applicationId, timeBucket); List instanceList = new LinkedList<>(); H2Client client = getClient(); - String sql = MessageFormat.format(GET_INSTANCES_SQL, InstanceTable.TABLE, InstanceTable.COLUMN_APPLICATION_ID, InstanceTable.COLUMN_HEARTBEAT_TIME); + String sql = SqlBuilder.buildSql(GET_INSTANCES_SQL, InstanceTable.TABLE, InstanceTable.COLUMN_APPLICATION_ID, InstanceTable.COLUMN_HEARTBEAT_TIME); Object[] params = new Object[]{applicationId, timeBucket}; try (ResultSet rs = client.executeQuery(sql, params)) { while (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 index c1882d9ce..70b5dc971 100644 --- 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 @@ -18,22 +18,23 @@ package org.skywalking.apm.collector.ui.dao; -import com.google.gson.JsonArray; -import com.google.gson.JsonObject; +import java.sql.ResultSet; +import java.sql.SQLException; +import java.util.ArrayList; +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.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.SqlBuilder; 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; +import com.google.gson.JsonArray; +import com.google.gson.JsonObject; /** * @author clevertension @@ -45,7 +46,7 @@ public class MemoryMetricH2DAO extends H2DAO implements IMemoryMetricDAO { @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"); + String sql = SqlBuilder.buildSql(GET_MEMORY_METRIC_SQL, MemoryMetricTable.TABLE, "id"); Object[] params = new Object[]{id}; JsonObject metric = new JsonObject(); try (ResultSet rs = client.executeQuery(sql, params)) { @@ -66,7 +67,7 @@ public class MemoryMetricH2DAO extends H2DAO implements IMemoryMetricDAO { @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"); + String sql = SqlBuilder.buildSql(GET_MEMORY_METRICS_SQL, MemoryMetricTable.TABLE, "id"); List idList = new ArrayList<>(); long timeBucket = startTimeBucket; do { 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 index 556c5ef88..2d567f91e 100644 --- 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 @@ -18,22 +18,23 @@ package org.skywalking.apm.collector.ui.dao; -import com.google.gson.JsonArray; -import com.google.gson.JsonObject; +import java.sql.ResultSet; +import java.sql.SQLException; +import java.util.ArrayList; +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.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.SqlBuilder; 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; +import com.google.gson.JsonArray; +import com.google.gson.JsonObject; /** * @author clevertension @@ -45,7 +46,7 @@ public class MemoryPoolMetricH2DAO extends H2DAO implements IMemoryPoolMetricDAO @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"); + String sql = SqlBuilder.buildSql(GET_MEMORY_POOL_METRIC_SQL, MemoryPoolMetricTable.TABLE, "id"); Object[] params = new Object[]{id}; JsonObject metric = new JsonObject(); try (ResultSet rs = client.executeQuery(sql, params)) { @@ -66,7 +67,7 @@ public class MemoryPoolMetricH2DAO extends H2DAO implements IMemoryPoolMetricDAO @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"); + String sql = SqlBuilder.buildSql(GET_MEMORY_POOL_METRICS_SQL, MemoryPoolMetricTable.TABLE, "id"); List idList = new ArrayList<>(); long timeBucket = startTimeBucket; do { 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 58dfc6269..5fd855025 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 @@ -18,21 +18,22 @@ package org.skywalking.apm.collector.ui.dao; -import com.google.gson.JsonArray; -import com.google.gson.JsonObject; +import java.sql.ResultSet; +import java.sql.SQLException; + 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.NodeComponentTable; +import org.skywalking.apm.collector.storage.h2.SqlBuilder; import org.skywalking.apm.collector.storage.h2.dao.H2DAO; import org.skywalking.apm.collector.ui.cache.ApplicationCache; import org.skywalking.apm.network.trace.component.ComponentsDefine; import org.slf4j.Logger; import org.slf4j.LoggerFactory; -import java.sql.ResultSet; -import java.sql.SQLException; -import java.text.MessageFormat; +import com.google.gson.JsonArray; +import com.google.gson.JsonObject; /** * @author pengys5, clevertension @@ -49,7 +50,7 @@ public class NodeComponentH2DAO extends H2DAO implements INodeComponentDAO { H2Client client = getClient(); JsonArray nodeComponentArray = new JsonArray(); - String sql = MessageFormat.format(AGGREGATE_COMPONENT_SQL, NodeComponentTable.COLUMN_COMPONENT_ID, + String sql = SqlBuilder.buildSql(AGGREGATE_COMPONENT_SQL, NodeComponentTable.COLUMN_COMPONENT_ID, NodeComponentTable.COLUMN_PEER, NodeComponentTable.COLUMN_PEER_ID, NodeComponentTable.TABLE, NodeComponentTable.COLUMN_TIME_BUCKET); Object[] params = new Object[]{startTime, endTime}; 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 10873ea38..7febe8065 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 @@ -18,20 +18,21 @@ package org.skywalking.apm.collector.ui.dao; -import com.google.gson.JsonArray; -import com.google.gson.JsonObject; +import java.sql.ResultSet; +import java.sql.SQLException; + 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.h2.SqlBuilder; 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 com.google.gson.JsonArray; +import com.google.gson.JsonObject; /** * @author pengys5, clevertension @@ -42,7 +43,7 @@ public class NodeMappingH2DAO extends H2DAO implements INodeMappingDAO { @Override public JsonArray load(long startTime, long endTime) { H2Client client = getClient(); JsonArray nodeMappingArray = new JsonArray(); - String sql = MessageFormat.format(NODE_MAPPING_SQL, NodeMappingTable.COLUMN_APPLICATION_ID, + String sql = SqlBuilder.buildSql(NODE_MAPPING_SQL, NodeMappingTable.COLUMN_APPLICATION_ID, NodeMappingTable.COLUMN_ADDRESS_ID, NodeMappingTable.COLUMN_ADDRESS, NodeMappingTable.TABLE, NodeMappingTable.COLUMN_TIME_BUCKET); 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 91c7bdbbb..52cdf9a41 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 @@ -18,20 +18,21 @@ package org.skywalking.apm.collector.ui.dao; -import com.google.gson.JsonArray; -import com.google.gson.JsonObject; +import java.sql.ResultSet; +import java.sql.SQLException; + 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.noderef.NodeReferenceTable; +import org.skywalking.apm.collector.storage.h2.SqlBuilder; 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 com.google.gson.JsonArray; +import com.google.gson.JsonObject; /** * @author pengys5, clevertension @@ -43,7 +44,7 @@ public class NodeReferenceH2DAO extends H2DAO implements INodeReferenceDAO { @Override public JsonArray load(long startTime, long endTime) { H2Client client = getClient(); JsonArray nodeRefResSumArray = new JsonArray(); - String sql = MessageFormat.format(NODE_REFERENCE_SQL, NodeReferenceTable.COLUMN_S1_LTE, + String sql = SqlBuilder.buildSql(NODE_REFERENCE_SQL, NodeReferenceTable.COLUMN_S1_LTE, NodeReferenceTable.COLUMN_S3_LTE, NodeReferenceTable.COLUMN_S5_LTE, NodeReferenceTable.COLUMN_S5_GT, NodeReferenceTable.COLUMN_SUMMARY, NodeReferenceTable.COLUMN_ERROR, NodeReferenceTable.TABLE, NodeReferenceTable.COLUMN_TIME_BUCKET, 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 46713ad35..b992c6947 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 @@ -20,7 +20,6 @@ package org.skywalking.apm.collector.ui.dao; import java.sql.ResultSet; import java.sql.SQLException; -import java.text.MessageFormat; import java.util.ArrayList; import java.util.List; @@ -32,6 +31,7 @@ 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.SqlBuilder; import org.skywalking.apm.collector.storage.h2.dao.H2DAO; import org.slf4j.Logger; import org.slf4j.LoggerFactory; @@ -116,8 +116,7 @@ public class SegmentCostH2DAO extends H2DAO implements ISegmentCostDAO { } sql = sql + " limit " + from + "," + limit; - MessageFormat messageFormat = new MessageFormat(sql); - sql = messageFormat.format(columns.toArray(new Object[0])); + sql = SqlBuilder.buildSql(sql, columns); Object[] p = params.toArray(new Object[0]); JsonObject topSegPaging = new JsonObject(); 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 4cd79a917..079e2dc12 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 @@ -18,20 +18,21 @@ package org.skywalking.apm.collector.ui.dao; -import com.google.protobuf.InvalidProtocolBufferException; +import java.sql.ResultSet; +import java.sql.SQLException; +import java.util.Base64; + 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.SqlBuilder; 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; +import com.google.protobuf.InvalidProtocolBufferException; /** * @author pengys5, clevertension @@ -41,7 +42,7 @@ public class SegmentH2DAO extends H2DAO implements ISegmentDAO { 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, + String sql = SqlBuilder.buildSql(GET_SEGMENT_SQL, SegmentTable.COLUMN_DATA_BINARY, SegmentTable.TABLE, "id"); Object[] params = new Object[]{segmentId}; try (ResultSet rs = client.executeQuery(sql, params)) { 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 216e8db30..dcf71a00a 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 @@ -18,23 +18,24 @@ package org.skywalking.apm.collector.ui.dao; -import com.google.gson.JsonArray; -import com.google.gson.JsonObject; +import java.sql.ResultSet; +import java.sql.SQLException; +import java.util.ArrayList; +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.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.SqlBuilder; 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; +import com.google.gson.JsonArray; +import com.google.gson.JsonObject; /** * @author pengys5 @@ -67,8 +68,7 @@ public class ServiceEntryH2DAO extends H2DAO implements IServiceEntryDAO { columns.add(ServiceEntryTable.COLUMN_ENTRY_SERVICE_NAME); } sql = sql + " limit " + from + "," + size; - MessageFormat messageFormat = new MessageFormat(sql); - sql = messageFormat.format(columns.toArray(new Object[0])); + sql = SqlBuilder.buildSql(sql, columns); Object[] p = params.toArray(new Object[0]); JsonArray serviceArray = new JsonArray(); JsonObject response = new JsonObject(); 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 b17df8328..34f7f577f 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 @@ -18,18 +18,18 @@ package org.skywalking.apm.collector.ui.dao; +import java.sql.ResultSet; +import java.sql.SQLException; + 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.SqlBuilder; 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, clevertension */ @@ -39,7 +39,7 @@ public class ServiceNameH2DAO extends H2DAO implements IServiceNameDAO { private static final String GET_SERVICE_ID_SQL = "select {0} from {1} where {2} = ? and {3} = ? limit 1"; @Override public String getServiceName(int serviceId) { H2Client client = getClient(); - String sql = MessageFormat.format(GET_SERVICE_NAME_SQL, ServiceNameTable.COLUMN_SERVICE_NAME, + String sql = SqlBuilder.buildSql(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)) { @@ -54,7 +54,7 @@ public class ServiceNameH2DAO extends H2DAO implements IServiceNameDAO { @Override public int getServiceId(int applicationId, String serviceName) { H2Client client = getClient(); - String sql = MessageFormat.format(GET_SERVICE_ID_SQL, ServiceNameTable.COLUMN_SERVICE_ID, + String sql = SqlBuilder.buildSql(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)) { diff --git a/apm-collector/apm-collector-ui/src/main/java/org/skywalking/apm/collector/ui/dao/ServiceReferenceH2DAO.java b/apm-collector/apm-collector-ui/src/main/java/org/skywalking/apm/collector/ui/dao/ServiceReferenceH2DAO.java index c8e916776..37a818e0a 100644 --- a/apm-collector/apm-collector-ui/src/main/java/org/skywalking/apm/collector/ui/dao/ServiceReferenceH2DAO.java +++ b/apm-collector/apm-collector-ui/src/main/java/org/skywalking/apm/collector/ui/dao/ServiceReferenceH2DAO.java @@ -20,7 +20,6 @@ package org.skywalking.apm.collector.ui.dao; import java.sql.ResultSet; import java.sql.SQLException; -import java.text.MessageFormat; import java.util.Iterator; import java.util.LinkedHashMap; import java.util.Map; @@ -32,6 +31,7 @@ import org.skywalking.apm.collector.core.util.Const; import org.skywalking.apm.collector.core.util.ObjectUtils; import org.skywalking.apm.collector.core.util.StringUtils; import org.skywalking.apm.collector.storage.define.serviceref.ServiceReferenceTable; +import org.skywalking.apm.collector.storage.h2.SqlBuilder; import org.skywalking.apm.collector.storage.h2.dao.H2DAO; import org.skywalking.apm.collector.ui.cache.ServiceIdCache; import org.skywalking.apm.collector.ui.cache.ServiceNameCache; @@ -54,7 +54,7 @@ public class ServiceReferenceH2DAO extends H2DAO implements IServiceReferenceDAO @Override public JsonArray load(int entryServiceId, long startTime, long endTime) { H2Client client = getClient(); - String sql = MessageFormat.format(GET_SRV_REF_LOAD1, ServiceReferenceTable.TABLE, + String sql = SqlBuilder.buildSql(GET_SRV_REF_LOAD1, ServiceReferenceTable.TABLE, ServiceReferenceTable.COLUMN_TIME_BUCKET, ServiceReferenceTable.COLUMN_ENTRY_SERVICE_ID, ServiceReferenceTable.COLUMN_ENTRY_SERVICE_NAME, ServiceReferenceTable.COLUMN_FRONT_SERVICE_ID, ServiceReferenceTable.COLUMN_BEHIND_SERVICE_ID, ServiceReferenceTable.COLUMN_FRONT_SERVICE_NAME, ServiceReferenceTable.COLUMN_BEHIND_SERVICE_NAME, @@ -99,7 +99,7 @@ public class ServiceReferenceH2DAO extends H2DAO implements IServiceReferenceDAO @Override public JsonArray load(String entryServiceName, int entryApplicationId, long startTime, long endTime) { H2Client client = getClient(); - String sql = MessageFormat.format(GET_SRV_REF_LOAD2, ServiceReferenceTable.TABLE, + String sql = SqlBuilder.buildSql(GET_SRV_REF_LOAD2, ServiceReferenceTable.TABLE, ServiceReferenceTable.COLUMN_TIME_BUCKET, ServiceReferenceTable.COLUMN_ENTRY_SERVICE_NAME, ServiceReferenceTable.COLUMN_FRONT_SERVICE_ID, ServiceReferenceTable.COLUMN_BEHIND_SERVICE_ID, ServiceReferenceTable.COLUMN_FRONT_SERVICE_NAME, ServiceReferenceTable.COLUMN_BEHIND_SERVICE_NAME, @@ -110,7 +110,7 @@ public class ServiceReferenceH2DAO extends H2DAO implements IServiceReferenceDAO Object[] params = new Object[]{startTime, endTime, entryServiceName}; int entryServiceId = ServiceIdCache.get(entryApplicationId, entryServiceName); if (entryServiceId != 0) { - sql = MessageFormat.format(GET_SRV_REF_LOAD1, ServiceReferenceTable.TABLE, + sql = SqlBuilder.buildSql(GET_SRV_REF_LOAD1, ServiceReferenceTable.TABLE, ServiceReferenceTable.COLUMN_TIME_BUCKET, ServiceReferenceTable.COLUMN_ENTRY_SERVICE_ID, ServiceReferenceTable.COLUMN_ENTRY_SERVICE_NAME, ServiceReferenceTable.COLUMN_FRONT_SERVICE_ID, ServiceReferenceTable.COLUMN_BEHIND_SERVICE_ID, ServiceReferenceTable.COLUMN_FRONT_SERVICE_NAME, ServiceReferenceTable.COLUMN_BEHIND_SERVICE_NAME, From 80da64e4ae8f9956138941b7943b6c418b4c2d91 Mon Sep 17 00:00:00 2001 From: clevertension Date: Wed, 18 Oct 2017 09:48:38 +0800 Subject: [PATCH 7/7] update autcommit and remove rollback to storage data as much as possible --- .../org/skywalking/apm/collector/client/h2/H2Client.java | 3 +-- .../apm/collector/storage/h2/dao/BatchH2DAO.java | 8 +------- 2 files changed, 2 insertions(+), 9 deletions(-) diff --git a/apm-collector/apm-collector-client/src/main/java/org/skywalking/apm/collector/client/h2/H2Client.java b/apm-collector/apm-collector-client/src/main/java/org/skywalking/apm/collector/client/h2/H2Client.java index 60441b97e..8ab7c47d8 100644 --- a/apm-collector/apm-collector-client/src/main/java/org/skywalking/apm/collector/client/h2/H2Client.java +++ b/apm-collector/apm-collector-client/src/main/java/org/skywalking/apm/collector/client/h2/H2Client.java @@ -105,14 +105,13 @@ public class H2Client implements Client { boolean flag; Connection conn = getConnection(); try (PreparedStatement statement = conn.prepareStatement(sql)) { - conn.setAutoCommit(false); + conn.setAutoCommit(true); if (params != null) { for (int i = 0; i < params.length; i++) { statement.setObject(i + 1, params[i]); } } flag = statement.execute(); - conn.commit(); } catch (SQLException e) { throw new H2ClientException(e.getMessage(), e); } diff --git a/apm-collector/apm-collector-storage/src/main/java/org/skywalking/apm/collector/storage/h2/dao/BatchH2DAO.java b/apm-collector/apm-collector-storage/src/main/java/org/skywalking/apm/collector/storage/h2/dao/BatchH2DAO.java index 44c96664d..ac0989f42 100644 --- a/apm-collector/apm-collector-storage/src/main/java/org/skywalking/apm/collector/storage/h2/dao/BatchH2DAO.java +++ b/apm-collector/apm-collector-storage/src/main/java/org/skywalking/apm/collector/storage/h2/dao/BatchH2DAO.java @@ -45,7 +45,7 @@ public class BatchH2DAO extends H2DAO implements IBatchDAO { final Map batchSqls = new HashMap<>(); try { conn = getClient().getConnection(); - conn.setAutoCommit(false); + conn.setAutoCommit(true); PreparedStatement ps; for (Object entity : batchCollection) { H2SqlEntity e = getH2SqlEntity(entity); @@ -70,14 +70,8 @@ public class BatchH2DAO extends H2DAO implements IBatchDAO { for (String k : batchSqls.keySet()) { batchSqls.get(k).executeBatch(); } - conn.commit(); } catch (SQLException | H2ClientException e) { logger.error(e.getMessage(), e); - try { - conn.rollback(); - } catch (SQLException e1) { - logger.error(e.getMessage(), e1); - } } batchSqls.clear(); }