From 3b2e1ecce0704fe5d9aaa480c2da77e854c78098 Mon Sep 17 00:00:00 2001 From: donghun-cho Date: Tue, 25 Apr 2023 20:29:56 +0900 Subject: [PATCH 1/2] [#9903] system metric host management --- .../pinpoint/metric/web/MetricWebApp.java | 4 +- .../SystemMetricExclusionController.java | 123 ++++++++++++++++++ .../MetricWebMysqlDaoConfiguration.java | 55 ++++++++ .../metric/web/config/WebRegistryHandler.java | 3 + .../controller/SystemMetricController.java | 13 +- .../web/dao/SystemMetricHostExclusionDao.java | 22 ++++ .../web/dao/model/HostExclusionSearchKey.java | 37 ++++++ .../MysqlSystemMetricHostExclusionDao.java | 64 +++++++++ .../SystemMetricHostExclusionService.java | 25 ++++ .../SystemMetricHostExclusionServiceImpl.java | 98 ++++++++++++++ .../service/SystemMetricHostInfoService.java | 4 +- .../SystemMetricHostInfoServiceImpl.java | 37 +++++- .../web/view/SystemMetricHostGroupInfo.java | 22 ++++ .../metric/web/view/SystemMetricHostInfo.java | 21 +++ .../mysql/MetricHostExclusionMapper.xml | 50 +++++++ .../MetricWebCreateTableStateMent-mysql.sql | 13 ++ ...temMetricHostExclusionServiceImplTest.java | 104 +++++++++++++++ .../SystemMetricHostInfoServiceImplTest.java | 98 ++++++++++++-- .../metric/web/utill/metric/TagUtilsTest.java | 12 ++ 19 files changed, 780 insertions(+), 25 deletions(-) create mode 100644 metric-module/metric/src/main/java/com/navercorp/pinpoint/metric/web/authorization/controller/SystemMetricExclusionController.java create mode 100644 metric-module/metric/src/main/java/com/navercorp/pinpoint/metric/web/config/MetricWebMysqlDaoConfiguration.java create mode 100644 metric-module/metric/src/main/java/com/navercorp/pinpoint/metric/web/dao/SystemMetricHostExclusionDao.java create mode 100644 metric-module/metric/src/main/java/com/navercorp/pinpoint/metric/web/dao/model/HostExclusionSearchKey.java create mode 100644 metric-module/metric/src/main/java/com/navercorp/pinpoint/metric/web/dao/mysql/MysqlSystemMetricHostExclusionDao.java create mode 100644 metric-module/metric/src/main/java/com/navercorp/pinpoint/metric/web/service/SystemMetricHostExclusionService.java create mode 100644 metric-module/metric/src/main/java/com/navercorp/pinpoint/metric/web/service/SystemMetricHostExclusionServiceImpl.java create mode 100644 metric-module/metric/src/main/java/com/navercorp/pinpoint/metric/web/view/SystemMetricHostGroupInfo.java create mode 100644 metric-module/metric/src/main/java/com/navercorp/pinpoint/metric/web/view/SystemMetricHostInfo.java create mode 100644 metric-module/metric/src/main/resources/pinot-web/mapper/mysql/MetricHostExclusionMapper.xml create mode 100644 metric-module/metric/src/main/resources/pinot-web/sql/MetricWebCreateTableStateMent-mysql.sql create mode 100644 metric-module/metric/src/test/java/com/navercorp/pinpoint/metric/web/service/SystemMetricHostExclusionServiceImplTest.java diff --git a/metric-module/metric/src/main/java/com/navercorp/pinpoint/metric/web/MetricWebApp.java b/metric-module/metric/src/main/java/com/navercorp/pinpoint/metric/web/MetricWebApp.java index c41f4268e5e4..cb21a1fefd68 100644 --- a/metric-module/metric/src/main/java/com/navercorp/pinpoint/metric/web/MetricWebApp.java +++ b/metric-module/metric/src/main/java/com/navercorp/pinpoint/metric/web/MetricWebApp.java @@ -1,6 +1,7 @@ package com.navercorp.pinpoint.metric.web; +import com.navercorp.pinpoint.metric.web.config.MetricWebMysqlDaoConfiguration; import com.navercorp.pinpoint.metric.web.config.MetricWebPinotDaoConfiguration; import com.navercorp.pinpoint.pinot.config.PinotConfiguration; import org.springframework.context.annotation.ComponentScan; @@ -14,7 +15,8 @@ @Import({ WebMetricPropertySources.class, MetricWebPinotDaoConfiguration.class, - PinotConfiguration.class + PinotConfiguration.class, + MetricWebMysqlDaoConfiguration.class }) @Profile("metric") public class MetricWebApp { diff --git a/metric-module/metric/src/main/java/com/navercorp/pinpoint/metric/web/authorization/controller/SystemMetricExclusionController.java b/metric-module/metric/src/main/java/com/navercorp/pinpoint/metric/web/authorization/controller/SystemMetricExclusionController.java new file mode 100644 index 000000000000..b3f1fc010ec8 --- /dev/null +++ b/metric-module/metric/src/main/java/com/navercorp/pinpoint/metric/web/authorization/controller/SystemMetricExclusionController.java @@ -0,0 +1,123 @@ +package com.navercorp.pinpoint.metric.web.authorization.controller; + +import com.navercorp.pinpoint.metric.web.service.SystemMetricHostExclusionService; +import com.navercorp.pinpoint.metric.web.view.SystemMetricHostGroupInfo; +import com.navercorp.pinpoint.metric.web.view.SystemMetricHostInfo; +import com.navercorp.pinpoint.pinot.tenant.TenantProvider; +import org.apache.logging.log4j.LogManager; +import org.apache.logging.log4j.Logger; +import org.springframework.http.HttpStatus; +import org.springframework.web.bind.annotation.DeleteMapping; +import org.springframework.web.bind.annotation.GetMapping; +import org.springframework.web.bind.annotation.PostMapping; +import org.springframework.web.bind.annotation.RequestMapping; +import org.springframework.web.bind.annotation.RequestParam; +import org.springframework.web.bind.annotation.RestController; +import org.springframework.web.server.ResponseStatusException; + +import java.util.List; + +@RestController +@RequestMapping(value = "/exclusion/systemMetric") +public class SystemMetricExclusionController { + private final Logger logger = LogManager.getLogger(this.getClass()); + + private final SystemMetricHostExclusionService systemMetricHostExclusionService; + private final TenantProvider tenantProvider; + + public SystemMetricExclusionController(SystemMetricHostExclusionService systemMetricHostExclusionService, TenantProvider tenantProvider) { + this.systemMetricHostExclusionService = systemMetricHostExclusionService; + this.tenantProvider = tenantProvider; + } + + @GetMapping(value = "/hostGroup/hostGroupInfo") + public SystemMetricHostGroupInfo getHostGroupExclusionInfo(@RequestParam("hostGroupName") String hostGroupName) { + String tenantId = tenantProvider.getTenantId(); + return systemMetricHostExclusionService.getHostGroupInfo(tenantId, hostGroupName); + } + + @GetMapping(value = "/hostGroup/hostInfoList") + public List getHostExclusionInfoList( + @RequestParam("hostGroupName") String hostGroupName) { + String tenantId = tenantProvider.getTenantId(); + List result = systemMetricHostExclusionService.getHostInfoList(tenantId, hostGroupName); + + return result; + } + + @PostMapping(value = "/hostGroup") + public String insertHostGroupExclusion(@RequestParam("hostGroupName") String hostGroupName) { + logger.debug("add hostGroup exclusion - hostGroupName: [{}]", hostGroupName); + try { + systemMetricHostExclusionService.insertHostGroupExclusion(hostGroupName); + return "OK"; + } catch (Exception e) { + logger.error("error while adding hostGroup exclusion", e); + throw new ResponseStatusException(HttpStatus.INTERNAL_SERVER_ERROR, e.getMessage()); + } + } + + @DeleteMapping(value = "/hostGroup") + public String deleteHostGroupExclusion(@RequestParam("hostGroupName") String hostGroupName) { + logger.debug("delete host group exclusion - hostGroupName: [{}]", hostGroupName); + try { + systemMetricHostExclusionService.deleteHostGroupExclusion(hostGroupName); + return "OK"; + } catch (Exception e) { + logger.error("error while deleting hostGroup exclusion", e); + throw new ResponseStatusException(HttpStatus.INTERNAL_SERVER_ERROR, e.getMessage()); + } + } + + @PostMapping(value = "/hostGroup/host") + public String insertHostExclusion(@RequestParam("hostGroupName") String hostGroupName, + @RequestParam("hostName") String hostName) { + logger.debug("add host exclusion - hostGroupName: [{}], hostName: [{}]", hostGroupName, hostName); + try { + systemMetricHostExclusionService.insertHostExclusion(hostGroupName, hostName); + return "OK"; + } catch (Exception e) { + logger.error("error while adding host exclusion", e); + throw new ResponseStatusException(HttpStatus.INTERNAL_SERVER_ERROR, e.getMessage()); + } + } + + @DeleteMapping(value = "/hostGroup/host") + public String deleteHostExclusion(@RequestParam("hostGroupName") String hostGroupName, + @RequestParam("hostName") String hostName) { + logger.debug("delete host exclusion - hostGroupName: [{}], hostName: [{}]", hostGroupName, hostName); + try { + systemMetricHostExclusionService.deleteHostExclusion(hostGroupName, hostName); + return "OK"; + } catch (Exception e) { + logger.error("error while deleting host exclusion", e); + throw new ResponseStatusException(HttpStatus.INTERNAL_SERVER_ERROR, e.getMessage()); + } + } + + @DeleteMapping(value = "/hostGroup/unusedHosts") + public String deleteUnusedHostExclusions(@RequestParam("hostGroupName") String hostGroupName) { + logger.debug("delete unused host exclusions - hostGroupName: [{}]", hostGroupName); + String tenantId = tenantProvider.getTenantId(); + try { + systemMetricHostExclusionService.deleteUnusedHostExclusions(tenantId, hostGroupName); + return "OK"; + } catch (Exception e) { + logger.error("error while deleting unused host exclusions", e); + throw new ResponseStatusException(HttpStatus.INTERNAL_SERVER_ERROR, e.getMessage()); + } + } + + @DeleteMapping(value = "/unusedGroups") + public String deleteUnusedGroupExclusions() { + logger.debug("delete exclusions from unused groups"); + String tenantId = tenantProvider.getTenantId(); + try { + systemMetricHostExclusionService.deleteUnusedGroupExclusions(tenantId); + return "OK"; + } catch (Exception e) { + logger.error("error while deleting exclusions from unused groups", e); + throw new ResponseStatusException(HttpStatus.INTERNAL_SERVER_ERROR, e.getMessage()); + } + } +} diff --git a/metric-module/metric/src/main/java/com/navercorp/pinpoint/metric/web/config/MetricWebMysqlDaoConfiguration.java b/metric-module/metric/src/main/java/com/navercorp/pinpoint/metric/web/config/MetricWebMysqlDaoConfiguration.java new file mode 100644 index 000000000000..2c293037d635 --- /dev/null +++ b/metric-module/metric/src/main/java/com/navercorp/pinpoint/metric/web/config/MetricWebMysqlDaoConfiguration.java @@ -0,0 +1,55 @@ +package com.navercorp.pinpoint.metric.web.config; + +import com.navercorp.pinpoint.metric.collector.config.MyBatisRegistryHandler; +import com.navercorp.pinpoint.pinot.mybatis.MyBatisConfiguration; +import org.apache.ibatis.session.Configuration; +import org.apache.ibatis.session.SqlSessionFactory; +import org.apache.logging.log4j.LogManager; +import org.apache.logging.log4j.Logger; +import org.mybatis.spring.SqlSessionFactoryBean; +import org.mybatis.spring.SqlSessionTemplate; +import org.springframework.beans.factory.annotation.Qualifier; +import org.springframework.beans.factory.annotation.Value; +import org.springframework.context.annotation.Bean; +import org.springframework.core.io.Resource; + +import javax.sql.DataSource; + +@org.springframework.context.annotation.Configuration +public class MetricWebMysqlDaoConfiguration { + private final Logger logger = LogManager.getLogger(MetricWebMysqlDaoConfiguration.class); + + @Bean + public SqlSessionFactoryBean metricSqlSessionFactory( + @Qualifier("dataSource") DataSource dataSource, + @Value("classpath*:/pinot-web/mapper/mysql/*Mapper.xml") Resource[] mappers) { + + for (Resource mapper : mappers) { + logger.info("Mapper location: {}", mapper.getDescription()); + } + + SqlSessionFactoryBean sessionFactoryBean = new SqlSessionFactoryBean(); + sessionFactoryBean.setDataSource(dataSource); + sessionFactoryBean.setMapperLocations(mappers); + + Configuration config = MyBatisConfiguration.defaultConfiguration(); + sessionFactoryBean.setConfiguration(config); + + MyBatisRegistryHandler registry = registryHandler(); + registry.registerTypeAlias(config.getTypeAliasRegistry()); + + sessionFactoryBean.setFailFast(true); + + return sessionFactoryBean; + } + + private MyBatisRegistryHandler registryHandler() { + return new WebRegistryHandler(); + } + + @Bean + public SqlSessionTemplate metricSqlSessionTemplate( + @Qualifier("metricSqlSessionFactory") SqlSessionFactory sessionFactory) { + return new SqlSessionTemplate(sessionFactory); + } +} diff --git a/metric-module/metric/src/main/java/com/navercorp/pinpoint/metric/web/config/WebRegistryHandler.java b/metric-module/metric/src/main/java/com/navercorp/pinpoint/metric/web/config/WebRegistryHandler.java index 838379e88642..118715e459ff 100644 --- a/metric-module/metric/src/main/java/com/navercorp/pinpoint/metric/web/config/WebRegistryHandler.java +++ b/metric-module/metric/src/main/java/com/navercorp/pinpoint/metric/web/config/WebRegistryHandler.java @@ -3,6 +3,7 @@ import com.navercorp.pinpoint.metric.collector.config.MyBatisRegistryHandler; import com.navercorp.pinpoint.metric.common.config.CommonRegistryHandler; import com.navercorp.pinpoint.metric.common.model.Tag; +import com.navercorp.pinpoint.metric.web.dao.model.HostExclusionSearchKey; import com.navercorp.pinpoint.metric.web.dao.model.HostInfoSearchKey; import com.navercorp.pinpoint.metric.web.dao.model.MetricInfoSearchKey; import com.navercorp.pinpoint.metric.web.dao.model.MetricTagsSearchKey; @@ -45,6 +46,8 @@ public void registerTypeAlias(TypeAliasRegistry typeAliasRegistry) { typeAliasRegistry.registerAlias("metricInfoSearchKey", MetricInfoSearchKey.class); typeAliasRegistry.registerAlias("metricTagsSearchKey", MetricTagsSearchKey.class); typeAliasRegistry.registerAlias("hostInfoSearchKey", HostInfoSearchKey.class); + + typeAliasRegistry.registerAlias("hostExclusionSearchKey", HostExclusionSearchKey.class); } @Override diff --git a/metric-module/metric/src/main/java/com/navercorp/pinpoint/metric/web/controller/SystemMetricController.java b/metric-module/metric/src/main/java/com/navercorp/pinpoint/metric/web/controller/SystemMetricController.java index 40e45d30b55e..72b5785a0530 100644 --- a/metric-module/metric/src/main/java/com/navercorp/pinpoint/metric/web/controller/SystemMetricController.java +++ b/metric-module/metric/src/main/java/com/navercorp/pinpoint/metric/web/controller/SystemMetricController.java @@ -1,5 +1,5 @@ /* - * Copyright 2020 NAVER Corp. + * Copyright 2023 NAVER Corp. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -50,7 +50,7 @@ public class SystemMetricController { private final TenantProvider tenantProvider; private final TimeWindowSampler DEFAULT_TIME_WINDOW_SAMPLER = new TimeWindowSlotCentricSampler(10000L, 200); - + public SystemMetricController(SystemMetricDataService systemMetricDataService, SystemMetricHostInfoService systemMetricHostInfoService, YMLSystemMetricBasicGroupManager systemMetricBasicGroupManager, @@ -62,15 +62,16 @@ public SystemMetricController(SystemMetricDataService systemMetricDataService, } @GetMapping(value = "/hostGroup") - public List getHostGroup() { + public List getHostGroup(@RequestParam(value = "showAll", defaultValue = "false", required = false) boolean showAll) { String tenantId = tenantProvider.getTenantId(); - return systemMetricHostInfoService.getHostGroupNameList(tenantId); + return systemMetricHostInfoService.getHostGroupNameList(tenantId, showAll); } @GetMapping(value = "/hostGroup/host") - public List getHostGroup(@RequestParam("hostGroupName") String hostGroupName) { + public List getHostGroup(@RequestParam("hostGroupName") String hostGroupName, + @RequestParam(value = "showAll", defaultValue = "false", required = false) boolean showAll) { String tenantId = tenantProvider.getTenantId(); - return systemMetricHostInfoService.getHostList(tenantId, hostGroupName); + return systemMetricHostInfoService.getHostList(tenantId, hostGroupName, showAll); } @GetMapping(value = "/hostGroup/host/collectedMetricInfoV2") diff --git a/metric-module/metric/src/main/java/com/navercorp/pinpoint/metric/web/dao/SystemMetricHostExclusionDao.java b/metric-module/metric/src/main/java/com/navercorp/pinpoint/metric/web/dao/SystemMetricHostExclusionDao.java new file mode 100644 index 000000000000..7f6698f2358b --- /dev/null +++ b/metric-module/metric/src/main/java/com/navercorp/pinpoint/metric/web/dao/SystemMetricHostExclusionDao.java @@ -0,0 +1,22 @@ +package com.navercorp.pinpoint.metric.web.dao; + +import java.util.List; + +public interface SystemMetricHostExclusionDao { + + List selectExcludedHostGroupNameList(); + + void insertHostGroupExclusion(String hostGroupName); + + void deleteHostGroupExclusion(String hostGroupName); + + List selectExcludedHostNameList(String hostGroupName); + + void insertHostExclusion(String hostGroupName, String hostName); + + void deleteHostExclusion(String hostGroupName, String hostName); + + void deleteHostExclusions(String hostGroupName); + + List selectGroupNameListFromHostExclusion(); +} \ No newline at end of file diff --git a/metric-module/metric/src/main/java/com/navercorp/pinpoint/metric/web/dao/model/HostExclusionSearchKey.java b/metric-module/metric/src/main/java/com/navercorp/pinpoint/metric/web/dao/model/HostExclusionSearchKey.java new file mode 100644 index 000000000000..f526c2b14806 --- /dev/null +++ b/metric-module/metric/src/main/java/com/navercorp/pinpoint/metric/web/dao/model/HostExclusionSearchKey.java @@ -0,0 +1,37 @@ +/* + * Copyright 2023 NAVER Corp. + * + * 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. + */ + +package com.navercorp.pinpoint.metric.web.dao.model; + +import java.util.Objects; + +public class HostExclusionSearchKey { + private final String hostGroupName; + private final String hostName; + + public HostExclusionSearchKey(String hostGroupName, String hostName) { + this.hostGroupName = Objects.requireNonNull(hostGroupName, "hostGroupName"); + this.hostName = Objects.requireNonNull(hostName, "hostName"); + } + + public String getHostGroupName() { + return hostGroupName; + } + + public String getHostName() { + return hostName; + } +} diff --git a/metric-module/metric/src/main/java/com/navercorp/pinpoint/metric/web/dao/mysql/MysqlSystemMetricHostExclusionDao.java b/metric-module/metric/src/main/java/com/navercorp/pinpoint/metric/web/dao/mysql/MysqlSystemMetricHostExclusionDao.java new file mode 100644 index 000000000000..127b2aa21b31 --- /dev/null +++ b/metric-module/metric/src/main/java/com/navercorp/pinpoint/metric/web/dao/mysql/MysqlSystemMetricHostExclusionDao.java @@ -0,0 +1,64 @@ +package com.navercorp.pinpoint.metric.web.dao.mysql; + +import com.navercorp.pinpoint.metric.web.dao.SystemMetricHostExclusionDao; +import com.navercorp.pinpoint.metric.web.dao.model.HostExclusionSearchKey; +import org.mybatis.spring.SqlSessionTemplate; +import org.springframework.beans.factory.annotation.Qualifier; +import org.springframework.context.annotation.Primary; +import org.springframework.stereotype.Repository; + +import java.util.List; +import java.util.Objects; + +@Primary +@Repository +public class MysqlSystemMetricHostExclusionDao implements SystemMetricHostExclusionDao { + + private static final String NAMESPACE = MysqlSystemMetricHostExclusionDao.class.getName() + "."; + + private final SqlSessionTemplate sqlMetricSessionTemplate; + + public MysqlSystemMetricHostExclusionDao(@Qualifier("metricSqlSessionTemplate") SqlSessionTemplate sqlMetricSessionTemplate) { + this.sqlMetricSessionTemplate = Objects.requireNonNull(sqlMetricSessionTemplate, "sqlSessionTemplate"); + } + + @Override + public List selectExcludedHostGroupNameList() { + return sqlMetricSessionTemplate.selectList(NAMESPACE + "selectExcludedHostGroupNames"); + } + + @Override + public void insertHostGroupExclusion(String hostGroupName) { + sqlMetricSessionTemplate.insert(NAMESPACE + "insertHostGroupExclusion", hostGroupName); + } + + @Override + public void deleteHostGroupExclusion(String hostGroupName) { + sqlMetricSessionTemplate.delete(NAMESPACE + "deleteHostGroupExclusion", hostGroupName); + } + + @Override + public List selectExcludedHostNameList(String hostGroupName) { + return sqlMetricSessionTemplate.selectList(NAMESPACE + "selectExcludedHostNames", hostGroupName); + } + + @Override + public void insertHostExclusion(String hostGroupName, String hostName) { + sqlMetricSessionTemplate.insert(NAMESPACE + "insertHostExclusion", new HostExclusionSearchKey(hostGroupName, hostName)); + } + + @Override + public void deleteHostExclusion(String hostGroupName, String hostName) { + sqlMetricSessionTemplate.delete(NAMESPACE + "deleteHostExclusion", new HostExclusionSearchKey(hostGroupName, hostName)); + } + + @Override + public void deleteHostExclusions(String hostGroupName) { + sqlMetricSessionTemplate.delete(NAMESPACE + "deleteHostExclusions", hostGroupName); + } + + @Override + public List selectGroupNameListFromHostExclusion() { + return sqlMetricSessionTemplate.selectList(NAMESPACE + "selectGroupNamesFromHostExclusion"); + } +} diff --git a/metric-module/metric/src/main/java/com/navercorp/pinpoint/metric/web/service/SystemMetricHostExclusionService.java b/metric-module/metric/src/main/java/com/navercorp/pinpoint/metric/web/service/SystemMetricHostExclusionService.java new file mode 100644 index 000000000000..18b80a66d9c6 --- /dev/null +++ b/metric-module/metric/src/main/java/com/navercorp/pinpoint/metric/web/service/SystemMetricHostExclusionService.java @@ -0,0 +1,25 @@ +package com.navercorp.pinpoint.metric.web.service; + +import com.navercorp.pinpoint.metric.web.view.SystemMetricHostGroupInfo; +import com.navercorp.pinpoint.metric.web.view.SystemMetricHostInfo; + +import java.util.List; + +public interface SystemMetricHostExclusionService { + + SystemMetricHostGroupInfo getHostGroupInfo(String tenantId, String hostGroupName); + + List getHostInfoList(String tenantId, String hostGroupName); + + void insertHostGroupExclusion(String hostGroupName); + + void deleteHostGroupExclusion(String hostGroupName); + + void insertHostExclusion(String hostGroupName, String hostName); + + void deleteHostExclusion(String hostGroupName, String hostName); + + void deleteUnusedHostExclusions(String tenantId, String hostGroupName); + + void deleteUnusedGroupExclusions(String tenantId); +} \ No newline at end of file diff --git a/metric-module/metric/src/main/java/com/navercorp/pinpoint/metric/web/service/SystemMetricHostExclusionServiceImpl.java b/metric-module/metric/src/main/java/com/navercorp/pinpoint/metric/web/service/SystemMetricHostExclusionServiceImpl.java new file mode 100644 index 000000000000..7873490a156d --- /dev/null +++ b/metric-module/metric/src/main/java/com/navercorp/pinpoint/metric/web/service/SystemMetricHostExclusionServiceImpl.java @@ -0,0 +1,98 @@ +package com.navercorp.pinpoint.metric.web.service; + +import com.navercorp.pinpoint.metric.web.dao.SystemMetricHostExclusionDao; +import com.navercorp.pinpoint.metric.web.dao.SystemMetricHostInfoDao; +import com.navercorp.pinpoint.metric.web.view.SystemMetricHostGroupInfo; +import com.navercorp.pinpoint.metric.web.view.SystemMetricHostInfo; +import org.springframework.stereotype.Service; +import org.springframework.transaction.annotation.Transactional; + +import java.util.ArrayList; +import java.util.Comparator; +import java.util.List; +import java.util.Objects; + +@Service +@Transactional(rollbackFor = {Exception.class}) +public class SystemMetricHostExclusionServiceImpl implements SystemMetricHostExclusionService { + + private final SystemMetricHostInfoDao systemMetricHostInfoDao; + private final SystemMetricHostExclusionDao systemMetricHostExclusionDao; + + public SystemMetricHostExclusionServiceImpl(SystemMetricHostInfoDao systemMetricHostInfoDao, SystemMetricHostExclusionDao systemMetricHostExclusionDao) { + this.systemMetricHostInfoDao = Objects.requireNonNull(systemMetricHostInfoDao, "systemMetricHostInfoDao"); + this.systemMetricHostExclusionDao = Objects.requireNonNull(systemMetricHostExclusionDao, "systemMetricHostExclusionDao"); + } + + @Override + public SystemMetricHostGroupInfo getHostGroupInfo(String tenantId, String hostGroupName) { + boolean excluded = systemMetricHostExclusionDao.selectExcludedHostGroupNameList().contains(hostGroupName); + return new SystemMetricHostGroupInfo(hostGroupName, excluded); + } + + @Override + public List getHostInfoList(String tenantId, String hostGroupName) { + List result = new ArrayList<>(); + List hostNames = systemMetricHostInfoDao.selectHostList(tenantId, hostGroupName); + List excludedHostNames = systemMetricHostExclusionDao.selectExcludedHostNameList(hostGroupName); + for (String hostName : hostNames) { + result.add(new SystemMetricHostInfo(hostName, excludedHostNames.contains(hostName))); + } + for (String excludedHostName : excludedHostNames) { + if (!hostNames.contains(excludedHostName)) { + result.add(new SystemMetricHostInfo(excludedHostName, true)); + } + } + + result.sort(Comparator.comparing(SystemMetricHostInfo::getHostName)); + return result; + } + + @Override + public void insertHostGroupExclusion(String hostGroupName) { + systemMetricHostExclusionDao.insertHostGroupExclusion(hostGroupName); + } + + @Override + public void deleteHostGroupExclusion(String hostGroupName) { + systemMetricHostExclusionDao.deleteHostGroupExclusion(hostGroupName); + } + + @Override + public void insertHostExclusion(String hostGroupName, String hostName) { + systemMetricHostExclusionDao.insertHostExclusion(hostGroupName, hostName); + } + + @Override + public void deleteHostExclusion(String hostGroupName, String hostName) { + systemMetricHostExclusionDao.deleteHostExclusion(hostGroupName, hostName); + } + + @Override + public void deleteUnusedHostExclusions(String tenantId, String hostGroupName) { + List hostNames = systemMetricHostInfoDao.selectHostList(tenantId, hostGroupName); + List excludedHostNames = systemMetricHostExclusionDao.selectExcludedHostNameList(hostGroupName); + for (String excludedHostName : excludedHostNames) { + if (!hostNames.contains(excludedHostName)) { + systemMetricHostExclusionDao.deleteHostExclusion(hostGroupName, excludedHostName); + } + } + } + + @Override + public void deleteUnusedGroupExclusions(String tenantId) { + List hostGroupNames = systemMetricHostInfoDao.selectHostGroupNameList(tenantId); + List hostGroupExclusionNames = systemMetricHostExclusionDao.selectExcludedHostGroupNameList(); + for (String excludedHostGroupName : hostGroupExclusionNames) { + if (!hostGroupNames.contains(excludedHostGroupName)) { + systemMetricHostExclusionDao.deleteHostGroupExclusion(excludedHostGroupName); + } + } + List hostExclusionGroupNames = systemMetricHostExclusionDao.selectGroupNameListFromHostExclusion(); + for (String hostExclusionGroupName : hostExclusionGroupNames) { + if (!hostGroupNames.contains(hostExclusionGroupName)) { + systemMetricHostExclusionDao.deleteHostExclusions(hostExclusionGroupName); + } + } + } +} \ No newline at end of file diff --git a/metric-module/metric/src/main/java/com/navercorp/pinpoint/metric/web/service/SystemMetricHostInfoService.java b/metric-module/metric/src/main/java/com/navercorp/pinpoint/metric/web/service/SystemMetricHostInfoService.java index 6285163a072f..468055b8b0f9 100644 --- a/metric-module/metric/src/main/java/com/navercorp/pinpoint/metric/web/service/SystemMetricHostInfoService.java +++ b/metric-module/metric/src/main/java/com/navercorp/pinpoint/metric/web/service/SystemMetricHostInfoService.java @@ -28,9 +28,9 @@ * @author minwoo.jung */ public interface SystemMetricHostInfoService { - List getHostGroupNameList(String tenantId); + List getHostGroupNameList(String tenantId, boolean showAll); - List getHostList(String tenantId, String hostGroupName); + List getHostList(String tenantId, String hostGroupName, boolean showAll); List getCollectedMetricInfoV2(String tenantId, String hostGroupName, String hostName); diff --git a/metric-module/metric/src/main/java/com/navercorp/pinpoint/metric/web/service/SystemMetricHostInfoServiceImpl.java b/metric-module/metric/src/main/java/com/navercorp/pinpoint/metric/web/service/SystemMetricHostInfoServiceImpl.java index 6eeea823ba85..7a10670233df 100644 --- a/metric-module/metric/src/main/java/com/navercorp/pinpoint/metric/web/service/SystemMetricHostInfoServiceImpl.java +++ b/metric-module/metric/src/main/java/com/navercorp/pinpoint/metric/web/service/SystemMetricHostInfoServiceImpl.java @@ -1,5 +1,5 @@ /* - * Copyright 2021 NAVER Corp. + * Copyright 2023 NAVER Corp. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -16,15 +16,19 @@ package com.navercorp.pinpoint.metric.web.service; +import com.navercorp.pinpoint.common.profiler.logging.ThrottledLogger; import com.navercorp.pinpoint.metric.common.model.MetricTag; import com.navercorp.pinpoint.metric.common.model.MetricTagCollection; import com.navercorp.pinpoint.metric.common.model.MetricTagKey; import com.navercorp.pinpoint.metric.common.model.Tag; +import com.navercorp.pinpoint.metric.web.dao.SystemMetricHostExclusionDao; import com.navercorp.pinpoint.metric.web.dao.SystemMetricHostInfoDao; import com.navercorp.pinpoint.metric.web.mapping.Field; import com.navercorp.pinpoint.metric.web.model.MetricDataSearchKey; import com.navercorp.pinpoint.metric.web.model.MetricInfo; import com.navercorp.pinpoint.metric.web.model.basic.metric.group.MatchingRule; +import org.apache.logging.log4j.LogManager; +import org.apache.logging.log4j.Logger; import org.springframework.stereotype.Service; import java.util.ArrayList; @@ -39,29 +43,50 @@ */ @Service public class SystemMetricHostInfoServiceImpl implements SystemMetricHostInfoService { + private final Logger logger = LogManager.getLogger(this.getClass()); + private final ThrottledLogger throttledLogger = ThrottledLogger.getLogger(logger, 100); private final SystemMetricHostInfoDao systemMetricHostInfoDao; private final YMLSystemMetricBasicGroupManager systemMetricBasicGroupManager; + private final SystemMetricHostExclusionDao systemMetricHostExclusionDao; public SystemMetricHostInfoServiceImpl(SystemMetricHostInfoDao systemMetricHostInfoDao, - YMLSystemMetricBasicGroupManager systemMetricBasicGroupManager) { + YMLSystemMetricBasicGroupManager systemMetricBasicGroupManager, + SystemMetricHostExclusionDao systemMetricHostExclusionDao) { this.systemMetricHostInfoDao = Objects.requireNonNull(systemMetricHostInfoDao, "systemMetricHostInfoDao"); this.systemMetricBasicGroupManager = Objects.requireNonNull(systemMetricBasicGroupManager, "systemMetricBasicGroupManager"); + this.systemMetricHostExclusionDao = Objects.requireNonNull(systemMetricHostExclusionDao, "systemMetricHostExclusionDao"); } @Override - public List getHostGroupNameList(String tenantId) { + public List getHostGroupNameList(String tenantId, boolean showAll) { List hostGroupNameList = systemMetricHostInfoDao.selectHostGroupNameList(tenantId); - hostGroupNameList.sort(Comparator.naturalOrder()); + if (!showAll){ + try { + List excludedHostGroupList = systemMetricHostExclusionDao.selectExcludedHostGroupNameList(); + hostGroupNameList.removeAll(excludedHostGroupList); + } catch (Exception e) { + throttledLogger.warn("error getting excludedHostGroupNameList", e); + } + } + hostGroupNameList.sort(Comparator.naturalOrder()); return hostGroupNameList; } @Override - public List getHostList(String tenantId, String hostGroupName) { + public List getHostList(String tenantId, String hostGroupName, boolean showAll) { List hostList = systemMetricHostInfoDao.selectHostList(tenantId, hostGroupName); - hostList.sort(Comparator.naturalOrder()); + if (!showAll) { + try { + List excludedHostList = systemMetricHostExclusionDao.selectExcludedHostNameList(hostGroupName); + hostList.removeAll(excludedHostList); + } catch (Exception e) { + throttledLogger.warn("error getting excludedHostNameList", e); + } + } + hostList.sort(Comparator.naturalOrder()); return hostList; } diff --git a/metric-module/metric/src/main/java/com/navercorp/pinpoint/metric/web/view/SystemMetricHostGroupInfo.java b/metric-module/metric/src/main/java/com/navercorp/pinpoint/metric/web/view/SystemMetricHostGroupInfo.java new file mode 100644 index 000000000000..9b0c13d5617d --- /dev/null +++ b/metric-module/metric/src/main/java/com/navercorp/pinpoint/metric/web/view/SystemMetricHostGroupInfo.java @@ -0,0 +1,22 @@ +package com.navercorp.pinpoint.metric.web.view; + +import java.util.List; +import java.util.Objects; + +public class SystemMetricHostGroupInfo { + private final String hostGroupName; + private final boolean excluded; + + public SystemMetricHostGroupInfo(String hostGroupName, boolean excluded) { + this.hostGroupName = Objects.requireNonNull(hostGroupName, "hostGroupName"); + this.excluded = excluded; + } + + public String getHostGroupName() { + return hostGroupName; + } + + public boolean isExcluded() { + return excluded; + } +} diff --git a/metric-module/metric/src/main/java/com/navercorp/pinpoint/metric/web/view/SystemMetricHostInfo.java b/metric-module/metric/src/main/java/com/navercorp/pinpoint/metric/web/view/SystemMetricHostInfo.java new file mode 100644 index 000000000000..bbcc7b54a51c --- /dev/null +++ b/metric-module/metric/src/main/java/com/navercorp/pinpoint/metric/web/view/SystemMetricHostInfo.java @@ -0,0 +1,21 @@ +package com.navercorp.pinpoint.metric.web.view; + +import java.util.Objects; + +public class SystemMetricHostInfo { + private final String hostName; + private final boolean excluded; + + public SystemMetricHostInfo(String hostName, boolean excluded) { + this.hostName = Objects.requireNonNull(hostName, "hostName"); + this.excluded = excluded; + } + + public String getHostName() { + return hostName; + } + + public boolean isExcluded() { + return excluded; + } +} diff --git a/metric-module/metric/src/main/resources/pinot-web/mapper/mysql/MetricHostExclusionMapper.xml b/metric-module/metric/src/main/resources/pinot-web/mapper/mysql/MetricHostExclusionMapper.xml new file mode 100644 index 000000000000..0ba907febc68 --- /dev/null +++ b/metric-module/metric/src/main/resources/pinot-web/mapper/mysql/MetricHostExclusionMapper.xml @@ -0,0 +1,50 @@ + + + + + + + + + INSERT INTO system_metric_host_group_exclusion (hostGroupName) + VALUES (#{hostGroupName}) + + + + DELETE + FROM system_metric_host_group_exclusion + WHERE hostGroupName = #{hostGroupName} + + + + + + INSERT INTO system_metric_host_exclusion (hostGroupName, hostName) + VALUES (#{hostGroupName}, #{hostName}) + + + + DELETE + FROM system_metric_host_exclusion + WHERE hostGroupName = #{hostGroupName} + AND hostName = #{hostName} + + + + + + DELETE + FROM system_metric_host_exclusion + WHERE hostGroupName = #{hostGroupName} + + diff --git a/metric-module/metric/src/main/resources/pinot-web/sql/MetricWebCreateTableStateMent-mysql.sql b/metric-module/metric/src/main/resources/pinot-web/sql/MetricWebCreateTableStateMent-mysql.sql new file mode 100644 index 000000000000..d5f000fb3803 --- /dev/null +++ b/metric-module/metric/src/main/resources/pinot-web/sql/MetricWebCreateTableStateMent-mysql.sql @@ -0,0 +1,13 @@ +-- DROP TABLE system_metric_host_Group_exclusion; +-- DROP TABLE system_metric_host_exclusion; + +CREATE TABLE system_metric_host_Group_exclusion ( + hostGroupName VARCHAR(50), + PRIMARY KEY(hostGroupName) +); + +CREATE TABLE system_metric_host_exclusion ( + hostGroupName VARCHAR(50), + hostName VARCHAR(50), + PRIMARY KEY(hostGroupName, hostName) +); \ No newline at end of file diff --git a/metric-module/metric/src/test/java/com/navercorp/pinpoint/metric/web/service/SystemMetricHostExclusionServiceImplTest.java b/metric-module/metric/src/test/java/com/navercorp/pinpoint/metric/web/service/SystemMetricHostExclusionServiceImplTest.java new file mode 100644 index 000000000000..c1c419ad0b5b --- /dev/null +++ b/metric-module/metric/src/test/java/com/navercorp/pinpoint/metric/web/service/SystemMetricHostExclusionServiceImplTest.java @@ -0,0 +1,104 @@ +package com.navercorp.pinpoint.metric.web.service; + +import com.navercorp.pinpoint.metric.web.dao.SystemMetricHostExclusionDao; +import com.navercorp.pinpoint.metric.web.dao.SystemMetricHostInfoDao; +import com.navercorp.pinpoint.metric.web.view.SystemMetricHostGroupInfo; +import com.navercorp.pinpoint.metric.web.view.SystemMetricHostInfo; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.ExtendWith; +import org.mockito.Mock; +import org.mockito.junit.jupiter.MockitoExtension; + +import java.util.Comparator; +import java.util.List; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.mockito.Mockito.doNothing; +import static org.mockito.Mockito.lenient; +import static org.mockito.Mockito.never; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; + +@ExtendWith(MockitoExtension.class) +public class SystemMetricHostExclusionServiceImplTest { + + SystemMetricHostExclusionService systemMetricHostExclusionService; + + @Mock + SystemMetricHostInfoDao systemMetricHostInfoDao; + + @Mock + SystemMetricHostExclusionDao systemMetricHostExclusionDao; + + @BeforeEach + void setUp() { + systemMetricHostExclusionService = new SystemMetricHostExclusionServiceImpl(systemMetricHostInfoDao, systemMetricHostExclusionDao); + } + + @Test + public void getHostGroupExclusionInfoTest() { + when(systemMetricHostExclusionDao.selectExcludedHostGroupNameList()).thenReturn(List.of("excludedHostGroupName")); + SystemMetricHostGroupInfo hostGroupResult = systemMetricHostExclusionService.getHostGroupInfo("tenantId", "hostGroupName"); + + assertThat(hostGroupResult.getHostGroupName()).isEqualTo("hostGroupName"); + assertThat(hostGroupResult.isExcluded()).isFalse(); + } + + @Test + public void getEmptyHostGroupExclusionInfoTest() { + when(systemMetricHostExclusionDao.selectExcludedHostGroupNameList()).thenReturn(List.of()); + + SystemMetricHostGroupInfo hostGroupResult = systemMetricHostExclusionService.getHostGroupInfo("tenantId", "hostGroupName"); + + assertThat(hostGroupResult.getHostGroupName()).isEqualTo("hostGroupName"); + assertThat(hostGroupResult.isExcluded()).isFalse(); + } + + @Test + void getExcludedHostInfoTest() { + when(systemMetricHostInfoDao.selectHostList("tenantId", "hostGroupName")).thenReturn(List.of("hostName", "excludedHostName")); + when(systemMetricHostExclusionDao.selectExcludedHostNameList("hostGroupName")).thenReturn(List.of("excludedHostName", "anotherExcludedHostName")); + List hostResultList = systemMetricHostExclusionService.getHostInfoList("tenantId", "hostGroupName"); + + hostResultList.sort(Comparator.comparing(SystemMetricHostInfo::getHostName)); + assertThat(hostResultList.get(0).getHostName()).isEqualTo("anotherExcludedHostName"); + assertThat(hostResultList.get(0).isExcluded()).isTrue(); + assertThat(hostResultList.get(1).getHostName()).isEqualTo("excludedHostName"); + assertThat(hostResultList.get(1).isExcluded()).isTrue(); + assertThat(hostResultList.get(2).getHostName()).isEqualTo("hostName"); + assertThat(hostResultList.get(2).isExcluded()).isFalse(); + } + + @Test + public void deleteUnusedHostExclusionsTest() { + when(systemMetricHostExclusionDao.selectExcludedHostNameList("hostGroupName")).thenReturn(List.of("liveHostName", "deadHostName")); + when(systemMetricHostInfoDao.selectHostList("tenantId", "hostGroupName")).thenReturn(List.of("liveHostName")); + lenient().doNothing().when(systemMetricHostExclusionDao).deleteHostExclusion("hostGroupName", "liveHostName"); + doNothing().when(systemMetricHostExclusionDao).deleteHostExclusion("hostGroupName", "deadHostName"); + + systemMetricHostExclusionService.deleteUnusedHostExclusions("tenantId", "hostGroupName"); + + verify(systemMetricHostExclusionDao, never()).deleteHostExclusion("hostGroupName", "liveHostName"); + verify(systemMetricHostExclusionDao).deleteHostExclusion("hostGroupName", "deadHostName"); + } + + @Test + public void deleteUnusedGroupExclusionsTest() { + when(systemMetricHostExclusionDao.selectExcludedHostGroupNameList()).thenReturn(List.of("liveHostGroupName", "deadHostGroupName1")); + when(systemMetricHostExclusionDao.selectGroupNameListFromHostExclusion()).thenReturn(List.of("liveHostGroupName", "deadHostGroupName2")); + when(systemMetricHostInfoDao.selectHostGroupNameList("tenantId")).thenReturn(List.of("liveHostGroupName")); + + lenient().doNothing().when(systemMetricHostExclusionDao).deleteHostGroupExclusion("liveHostGroupName"); + lenient().doNothing().when(systemMetricHostExclusionDao).deleteHostExclusions("liveHostGroupName"); + doNothing().when(systemMetricHostExclusionDao).deleteHostGroupExclusion("deadHostGroupName1"); + doNothing().when(systemMetricHostExclusionDao).deleteHostExclusions("deadHostGroupName2"); + + systemMetricHostExclusionService.deleteUnusedGroupExclusions("tenantId"); + + verify(systemMetricHostExclusionDao, never()).deleteHostGroupExclusion("liveHostGroupName"); + verify(systemMetricHostExclusionDao, never()).deleteHostExclusions("liveHostGroupName"); + verify(systemMetricHostExclusionDao).deleteHostGroupExclusion("deadHostGroupName1"); + verify(systemMetricHostExclusionDao).deleteHostExclusions("deadHostGroupName2"); + } +} diff --git a/metric-module/metric/src/test/java/com/navercorp/pinpoint/metric/web/service/SystemMetricHostInfoServiceImplTest.java b/metric-module/metric/src/test/java/com/navercorp/pinpoint/metric/web/service/SystemMetricHostInfoServiceImplTest.java index 74dfd73b09cc..6993739b6da7 100644 --- a/metric-module/metric/src/test/java/com/navercorp/pinpoint/metric/web/service/SystemMetricHostInfoServiceImplTest.java +++ b/metric-module/metric/src/test/java/com/navercorp/pinpoint/metric/web/service/SystemMetricHostInfoServiceImplTest.java @@ -1,29 +1,107 @@ package com.navercorp.pinpoint.metric.web.service; -import com.navercorp.pinpoint.metric.common.model.Tag; -import org.apache.logging.log4j.LogManager; -import org.apache.logging.log4j.Logger; +import com.navercorp.pinpoint.metric.web.dao.SystemMetricHostExclusionDao; +import com.navercorp.pinpoint.metric.web.dao.SystemMetricHostInfoDao; +import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.ExtendWith; +import org.mockito.Mock; +import org.mockito.junit.jupiter.MockitoExtension; import java.util.ArrayList; import java.util.List; import static org.assertj.core.api.Assertions.assertThat; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; /** * @author minwoo.jung */ + +@ExtendWith(MockitoExtension.class) public class SystemMetricHostInfoServiceImplTest { - private final Logger logger = LogManager.getLogger(this.getClass()); + SystemMetricHostInfoService systemMetricHostInfoService; + + @Mock + SystemMetricHostInfoDao systemMetricHostInfoDao; + + @Mock + YMLSystemMetricBasicGroupManager ymlSystemMetricBasicGroupManager; + + @Mock + SystemMetricHostExclusionDao systemMetricHostExclusionDao; + + @BeforeEach + void setUp() { + systemMetricHostInfoService = new SystemMetricHostInfoServiceImpl(systemMetricHostInfoDao, ymlSystemMetricBasicGroupManager, systemMetricHostExclusionDao); + } + + @Test + public void hostGroupExclusionTest() { + List hostGroupNames = new ArrayList<>(); + hostGroupNames.add("hostGroupName1"); + hostGroupNames.add("hostGroupName2"); + + List excludedHostGroupNames = new ArrayList<>(); + excludedHostGroupNames.add("hostGroupName2"); + + when(systemMetricHostInfoDao.selectHostGroupNameList("tenantId")).thenReturn(hostGroupNames); + when(systemMetricHostExclusionDao.selectExcludedHostGroupNameList()).thenReturn(excludedHostGroupNames); + + List result = systemMetricHostInfoService.getHostGroupNameList("tenantId", false); + + verify(systemMetricHostInfoDao).selectHostGroupNameList("tenantId"); + verify(systemMetricHostExclusionDao).selectExcludedHostGroupNameList(); + assertThat(result).isEqualTo(List.of("hostGroupName1")); + } + + @Test + public void hostGroupExclusionErrorTest() { + List hostGroupNames = new ArrayList<>(); + hostGroupNames.add("hostGroupName1"); + hostGroupNames.add("hostGroupName2"); + + List excludedHostGroupNames = new ArrayList<>(); + excludedHostGroupNames.add("hostGroupName2"); + + when(systemMetricHostInfoDao.selectHostGroupNameList("tenantId")).thenReturn(hostGroupNames); + when(systemMetricHostExclusionDao.selectExcludedHostGroupNameList()).thenThrow(new RuntimeException("Test Exception")); + + List result = systemMetricHostInfoService.getHostGroupNameList("tenantId", false); + + verify(systemMetricHostInfoDao).selectHostGroupNameList("tenantId"); + verify(systemMetricHostExclusionDao).selectExcludedHostGroupNameList(); + assertThat(result).isEqualTo(hostGroupNames); + } + + @Test + public void hostExclusionTest() { + List hostNames = new ArrayList<>(); + hostNames.add("hostName1"); + hostNames.add("hostName2"); + when(systemMetricHostInfoDao.selectHostList("tenantId", "hostGroupName")).thenReturn(hostNames); + when(systemMetricHostExclusionDao.selectExcludedHostNameList("hostGroupName")).thenReturn(List.of("hostName1", "hostName3")); + + List result = systemMetricHostInfoService.getHostList("tenantId", "hostGroupName", false); + + verify(systemMetricHostInfoDao).selectHostList("tenantId", "hostGroupName"); + verify(systemMetricHostExclusionDao).selectExcludedHostNameList("hostGroupName"); + assertThat(result).isEqualTo(List.of("hostName2")); + } @Test - public void test() { - List tagList = List.of( - new Tag("key", "value") - ); + public void hostExclusionErrorTest() { + List hostNames = new ArrayList<>(); + hostNames.add("hostName1"); + hostNames.add("hostName2"); + when(systemMetricHostInfoDao.selectHostList("tenantId", "hostGroupName")).thenReturn(hostNames); + when(systemMetricHostExclusionDao.selectExcludedHostNameList("hostGroupName")).thenThrow(new RuntimeException("Test Exception")); - List comparedTagList = new ArrayList<>(); + List result = systemMetricHostInfoService.getHostList("tenantId", "hostGroupName", false); - assertThat(tagList).containsAll(comparedTagList); + verify(systemMetricHostInfoDao).selectHostList("tenantId", "hostGroupName"); + verify(systemMetricHostExclusionDao).selectExcludedHostNameList("hostGroupName"); + assertThat(result).isEqualTo(hostNames); } } \ No newline at end of file diff --git a/metric-module/metric/src/test/java/com/navercorp/pinpoint/metric/web/utill/metric/TagUtilsTest.java b/metric-module/metric/src/test/java/com/navercorp/pinpoint/metric/web/utill/metric/TagUtilsTest.java index 5b1900aeb5ab..4a438cc7aebf 100644 --- a/metric-module/metric/src/test/java/com/navercorp/pinpoint/metric/web/utill/metric/TagUtilsTest.java +++ b/metric-module/metric/src/test/java/com/navercorp/pinpoint/metric/web/utill/metric/TagUtilsTest.java @@ -5,12 +5,24 @@ import org.junit.jupiter.api.Assertions; import org.junit.jupiter.api.Test; +import java.util.ArrayList; import java.util.List; import static org.assertj.core.api.Assertions.assertThat; public class TagUtilsTest { + @Test + public void emptyListCompareTest() { + List tagList = List.of( + new Tag("key", "value") + ); + + List comparedTagList = new ArrayList<>(); + + assertThat(tagList).containsAll(comparedTagList); + } + @Test public void parseTagTest() { List tagList = List.of( From 1c8a1375ef78c26efce8836802ed024e64bbacc8 Mon Sep 17 00:00:00 2001 From: donghun-cho Date: Wed, 14 Jun 2023 19:55:35 +0900 Subject: [PATCH 2/2] [#9903] fix table names, change exclusion api --- .../controller/SystemMetricController.java | 13 ++++---- .../SystemMetricExclusionController.java | 32 +++++++------------ .../SystemMetricHostExclusionService.java | 6 ++-- .../SystemMetricHostExclusionServiceImpl.java | 26 +++++++-------- .../service/SystemMetricHostInfoService.java | 4 +-- .../SystemMetricHostInfoServiceImpl.java | 28 +++++++--------- .../mysql/MetricHostExclusionMapper.xml | 20 ++++++------ .../MetricWebCreateTableStateMent-mysql.sql | 18 +++++++---- ...temMetricHostExclusionServiceImplTest.java | 15 +-------- .../SystemMetricHostInfoServiceImplTest.java | 8 ++--- 10 files changed, 74 insertions(+), 96 deletions(-) rename metric-module/metric/src/main/java/com/navercorp/pinpoint/metric/web/{authorization => }/controller/SystemMetricExclusionController.java (82%) diff --git a/metric-module/metric/src/main/java/com/navercorp/pinpoint/metric/web/controller/SystemMetricController.java b/metric-module/metric/src/main/java/com/navercorp/pinpoint/metric/web/controller/SystemMetricController.java index 72b5785a0530..40e45d30b55e 100644 --- a/metric-module/metric/src/main/java/com/navercorp/pinpoint/metric/web/controller/SystemMetricController.java +++ b/metric-module/metric/src/main/java/com/navercorp/pinpoint/metric/web/controller/SystemMetricController.java @@ -1,5 +1,5 @@ /* - * Copyright 2023 NAVER Corp. + * Copyright 2020 NAVER Corp. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -50,7 +50,7 @@ public class SystemMetricController { private final TenantProvider tenantProvider; private final TimeWindowSampler DEFAULT_TIME_WINDOW_SAMPLER = new TimeWindowSlotCentricSampler(10000L, 200); - + public SystemMetricController(SystemMetricDataService systemMetricDataService, SystemMetricHostInfoService systemMetricHostInfoService, YMLSystemMetricBasicGroupManager systemMetricBasicGroupManager, @@ -62,16 +62,15 @@ public SystemMetricController(SystemMetricDataService systemMetricDataService, } @GetMapping(value = "/hostGroup") - public List getHostGroup(@RequestParam(value = "showAll", defaultValue = "false", required = false) boolean showAll) { + public List getHostGroup() { String tenantId = tenantProvider.getTenantId(); - return systemMetricHostInfoService.getHostGroupNameList(tenantId, showAll); + return systemMetricHostInfoService.getHostGroupNameList(tenantId); } @GetMapping(value = "/hostGroup/host") - public List getHostGroup(@RequestParam("hostGroupName") String hostGroupName, - @RequestParam(value = "showAll", defaultValue = "false", required = false) boolean showAll) { + public List getHostGroup(@RequestParam("hostGroupName") String hostGroupName) { String tenantId = tenantProvider.getTenantId(); - return systemMetricHostInfoService.getHostList(tenantId, hostGroupName, showAll); + return systemMetricHostInfoService.getHostList(tenantId, hostGroupName); } @GetMapping(value = "/hostGroup/host/collectedMetricInfoV2") diff --git a/metric-module/metric/src/main/java/com/navercorp/pinpoint/metric/web/authorization/controller/SystemMetricExclusionController.java b/metric-module/metric/src/main/java/com/navercorp/pinpoint/metric/web/controller/SystemMetricExclusionController.java similarity index 82% rename from metric-module/metric/src/main/java/com/navercorp/pinpoint/metric/web/authorization/controller/SystemMetricExclusionController.java rename to metric-module/metric/src/main/java/com/navercorp/pinpoint/metric/web/controller/SystemMetricExclusionController.java index b3f1fc010ec8..f87ca61c1d59 100644 --- a/metric-module/metric/src/main/java/com/navercorp/pinpoint/metric/web/authorization/controller/SystemMetricExclusionController.java +++ b/metric-module/metric/src/main/java/com/navercorp/pinpoint/metric/web/controller/SystemMetricExclusionController.java @@ -1,4 +1,4 @@ -package com.navercorp.pinpoint.metric.web.authorization.controller; +package com.navercorp.pinpoint.metric.web.controller; import com.navercorp.pinpoint.metric.web.service.SystemMetricHostExclusionService; import com.navercorp.pinpoint.metric.web.view.SystemMetricHostGroupInfo; @@ -30,19 +30,23 @@ public SystemMetricExclusionController(SystemMetricHostExclusionService systemMe this.tenantProvider = tenantProvider; } - @GetMapping(value = "/hostGroup/hostGroupInfo") + @GetMapping(value = "/hostGroup") + public List getHostGroupNameList() { + String tenantId = tenantProvider.getTenantId(); + return systemMetricHostExclusionService.getHostGroupNameList(tenantId); + } + + @GetMapping(value = "/hostGroup", params = {"hostGroupName"}) public SystemMetricHostGroupInfo getHostGroupExclusionInfo(@RequestParam("hostGroupName") String hostGroupName) { String tenantId = tenantProvider.getTenantId(); return systemMetricHostExclusionService.getHostGroupInfo(tenantId, hostGroupName); } - @GetMapping(value = "/hostGroup/hostInfoList") - public List getHostExclusionInfoList( - @RequestParam("hostGroupName") String hostGroupName) { + @GetMapping(value = "/hostGroup/host") + public List getHostExclusionInfoList(@RequestParam("hostGroupName") String hostGroupName, + @RequestParam(value = "orderBy", defaultValue = "hostName") String orderBy) { String tenantId = tenantProvider.getTenantId(); - List result = systemMetricHostExclusionService.getHostInfoList(tenantId, hostGroupName); - - return result; + return systemMetricHostExclusionService.getHostInfoList(tenantId, hostGroupName, orderBy); } @PostMapping(value = "/hostGroup") @@ -95,18 +99,6 @@ public String deleteHostExclusion(@RequestParam("hostGroupName") String hostGrou } } - @DeleteMapping(value = "/hostGroup/unusedHosts") - public String deleteUnusedHostExclusions(@RequestParam("hostGroupName") String hostGroupName) { - logger.debug("delete unused host exclusions - hostGroupName: [{}]", hostGroupName); - String tenantId = tenantProvider.getTenantId(); - try { - systemMetricHostExclusionService.deleteUnusedHostExclusions(tenantId, hostGroupName); - return "OK"; - } catch (Exception e) { - logger.error("error while deleting unused host exclusions", e); - throw new ResponseStatusException(HttpStatus.INTERNAL_SERVER_ERROR, e.getMessage()); - } - } @DeleteMapping(value = "/unusedGroups") public String deleteUnusedGroupExclusions() { diff --git a/metric-module/metric/src/main/java/com/navercorp/pinpoint/metric/web/service/SystemMetricHostExclusionService.java b/metric-module/metric/src/main/java/com/navercorp/pinpoint/metric/web/service/SystemMetricHostExclusionService.java index 18b80a66d9c6..29c9cd12472f 100644 --- a/metric-module/metric/src/main/java/com/navercorp/pinpoint/metric/web/service/SystemMetricHostExclusionService.java +++ b/metric-module/metric/src/main/java/com/navercorp/pinpoint/metric/web/service/SystemMetricHostExclusionService.java @@ -7,9 +7,11 @@ public interface SystemMetricHostExclusionService { + List getHostGroupNameList(String tenantId); + SystemMetricHostGroupInfo getHostGroupInfo(String tenantId, String hostGroupName); - List getHostInfoList(String tenantId, String hostGroupName); + List getHostInfoList(String tenantId, String hostGroupName, String orderBy); void insertHostGroupExclusion(String hostGroupName); @@ -19,7 +21,5 @@ public interface SystemMetricHostExclusionService { void deleteHostExclusion(String hostGroupName, String hostName); - void deleteUnusedHostExclusions(String tenantId, String hostGroupName); - void deleteUnusedGroupExclusions(String tenantId); } \ No newline at end of file diff --git a/metric-module/metric/src/main/java/com/navercorp/pinpoint/metric/web/service/SystemMetricHostExclusionServiceImpl.java b/metric-module/metric/src/main/java/com/navercorp/pinpoint/metric/web/service/SystemMetricHostExclusionServiceImpl.java index 7873490a156d..b6b5990f9fce 100644 --- a/metric-module/metric/src/main/java/com/navercorp/pinpoint/metric/web/service/SystemMetricHostExclusionServiceImpl.java +++ b/metric-module/metric/src/main/java/com/navercorp/pinpoint/metric/web/service/SystemMetricHostExclusionServiceImpl.java @@ -24,6 +24,13 @@ public SystemMetricHostExclusionServiceImpl(SystemMetricHostInfoDao systemMetric this.systemMetricHostExclusionDao = Objects.requireNonNull(systemMetricHostExclusionDao, "systemMetricHostExclusionDao"); } + @Override + public List getHostGroupNameList(String tenantId) { + List hostGroupNameList = systemMetricHostInfoDao.selectHostGroupNameList(tenantId); + hostGroupNameList.sort(Comparator.naturalOrder()); + return hostGroupNameList; + } + @Override public SystemMetricHostGroupInfo getHostGroupInfo(String tenantId, String hostGroupName) { boolean excluded = systemMetricHostExclusionDao.selectExcludedHostGroupNameList().contains(hostGroupName); @@ -31,7 +38,7 @@ public SystemMetricHostGroupInfo getHostGroupInfo(String tenantId, String hostGr } @Override - public List getHostInfoList(String tenantId, String hostGroupName) { + public List getHostInfoList(String tenantId, String hostGroupName, String orderBy) { List result = new ArrayList<>(); List hostNames = systemMetricHostInfoDao.selectHostList(tenantId, hostGroupName); List excludedHostNames = systemMetricHostExclusionDao.selectExcludedHostNameList(hostGroupName); @@ -44,7 +51,11 @@ public List getHostInfoList(String tenantId, String hostGr } } - result.sort(Comparator.comparing(SystemMetricHostInfo::getHostName)); + if ("excluded".equals(orderBy)) { + result.sort(Comparator.comparing(SystemMetricHostInfo::isExcluded)); + } else { + result.sort(Comparator.comparing(SystemMetricHostInfo::getHostName)); + } return result; } @@ -68,17 +79,6 @@ public void deleteHostExclusion(String hostGroupName, String hostName) { systemMetricHostExclusionDao.deleteHostExclusion(hostGroupName, hostName); } - @Override - public void deleteUnusedHostExclusions(String tenantId, String hostGroupName) { - List hostNames = systemMetricHostInfoDao.selectHostList(tenantId, hostGroupName); - List excludedHostNames = systemMetricHostExclusionDao.selectExcludedHostNameList(hostGroupName); - for (String excludedHostName : excludedHostNames) { - if (!hostNames.contains(excludedHostName)) { - systemMetricHostExclusionDao.deleteHostExclusion(hostGroupName, excludedHostName); - } - } - } - @Override public void deleteUnusedGroupExclusions(String tenantId) { List hostGroupNames = systemMetricHostInfoDao.selectHostGroupNameList(tenantId); diff --git a/metric-module/metric/src/main/java/com/navercorp/pinpoint/metric/web/service/SystemMetricHostInfoService.java b/metric-module/metric/src/main/java/com/navercorp/pinpoint/metric/web/service/SystemMetricHostInfoService.java index 468055b8b0f9..6285163a072f 100644 --- a/metric-module/metric/src/main/java/com/navercorp/pinpoint/metric/web/service/SystemMetricHostInfoService.java +++ b/metric-module/metric/src/main/java/com/navercorp/pinpoint/metric/web/service/SystemMetricHostInfoService.java @@ -28,9 +28,9 @@ * @author minwoo.jung */ public interface SystemMetricHostInfoService { - List getHostGroupNameList(String tenantId, boolean showAll); + List getHostGroupNameList(String tenantId); - List getHostList(String tenantId, String hostGroupName, boolean showAll); + List getHostList(String tenantId, String hostGroupName); List getCollectedMetricInfoV2(String tenantId, String hostGroupName, String hostName); diff --git a/metric-module/metric/src/main/java/com/navercorp/pinpoint/metric/web/service/SystemMetricHostInfoServiceImpl.java b/metric-module/metric/src/main/java/com/navercorp/pinpoint/metric/web/service/SystemMetricHostInfoServiceImpl.java index 7a10670233df..90b99b045073 100644 --- a/metric-module/metric/src/main/java/com/navercorp/pinpoint/metric/web/service/SystemMetricHostInfoServiceImpl.java +++ b/metric-module/metric/src/main/java/com/navercorp/pinpoint/metric/web/service/SystemMetricHostInfoServiceImpl.java @@ -59,15 +59,13 @@ public SystemMetricHostInfoServiceImpl(SystemMetricHostInfoDao systemMetricHostI } @Override - public List getHostGroupNameList(String tenantId, boolean showAll) { + public List getHostGroupNameList(String tenantId) { List hostGroupNameList = systemMetricHostInfoDao.selectHostGroupNameList(tenantId); - if (!showAll){ - try { - List excludedHostGroupList = systemMetricHostExclusionDao.selectExcludedHostGroupNameList(); - hostGroupNameList.removeAll(excludedHostGroupList); - } catch (Exception e) { - throttledLogger.warn("error getting excludedHostGroupNameList", e); - } + try { + List excludedHostGroupList = systemMetricHostExclusionDao.selectExcludedHostGroupNameList(); + hostGroupNameList.removeAll(excludedHostGroupList); + } catch (Exception e) { + throttledLogger.warn("error getting excludedHostGroupNameList", e); } hostGroupNameList.sort(Comparator.naturalOrder()); @@ -75,15 +73,13 @@ public List getHostGroupNameList(String tenantId, boolean showAll) { } @Override - public List getHostList(String tenantId, String hostGroupName, boolean showAll) { + public List getHostList(String tenantId, String hostGroupName) { List hostList = systemMetricHostInfoDao.selectHostList(tenantId, hostGroupName); - if (!showAll) { - try { - List excludedHostList = systemMetricHostExclusionDao.selectExcludedHostNameList(hostGroupName); - hostList.removeAll(excludedHostList); - } catch (Exception e) { - throttledLogger.warn("error getting excludedHostNameList", e); - } + try { + List excludedHostList = systemMetricHostExclusionDao.selectExcludedHostNameList(hostGroupName); + hostList.removeAll(excludedHostList); + } catch (Exception e) { + throttledLogger.warn("error getting excludedHostNameList", e); } hostList.sort(Comparator.naturalOrder()); diff --git a/metric-module/metric/src/main/resources/pinot-web/mapper/mysql/MetricHostExclusionMapper.xml b/metric-module/metric/src/main/resources/pinot-web/mapper/mysql/MetricHostExclusionMapper.xml index 0ba907febc68..f35786bb5d39 100644 --- a/metric-module/metric/src/main/resources/pinot-web/mapper/mysql/MetricHostExclusionMapper.xml +++ b/metric-module/metric/src/main/resources/pinot-web/mapper/mysql/MetricHostExclusionMapper.xml @@ -4,47 +4,47 @@ - INSERT INTO system_metric_host_group_exclusion (hostGroupName) + INSERT INTO system_metric_host_group_exclusion (host_group_name) VALUES (#{hostGroupName}) DELETE FROM system_metric_host_group_exclusion - WHERE hostGroupName = #{hostGroupName} + WHERE host_group_name = #{hostGroupName} - INSERT INTO system_metric_host_exclusion (hostGroupName, hostName) + INSERT INTO system_metric_host_exclusion (host_group_name, host_name) VALUES (#{hostGroupName}, #{hostName}) DELETE FROM system_metric_host_exclusion - WHERE hostGroupName = #{hostGroupName} - AND hostName = #{hostName} + WHERE host_group_name = #{hostGroupName} + AND host_name = #{hostName} DELETE FROM system_metric_host_exclusion - WHERE hostGroupName = #{hostGroupName} + WHERE host_group_name = #{hostGroupName} diff --git a/metric-module/metric/src/main/resources/pinot-web/sql/MetricWebCreateTableStateMent-mysql.sql b/metric-module/metric/src/main/resources/pinot-web/sql/MetricWebCreateTableStateMent-mysql.sql index d5f000fb3803..18ff0f540ca2 100644 --- a/metric-module/metric/src/main/resources/pinot-web/sql/MetricWebCreateTableStateMent-mysql.sql +++ b/metric-module/metric/src/main/resources/pinot-web/sql/MetricWebCreateTableStateMent-mysql.sql @@ -1,13 +1,17 @@ --- DROP TABLE system_metric_host_Group_exclusion; +-- DROP TABLE system_metric_host_group_exclusion; -- DROP TABLE system_metric_host_exclusion; -CREATE TABLE system_metric_host_Group_exclusion ( - hostGroupName VARCHAR(50), - PRIMARY KEY(hostGroupName) +CREATE TABLE system_metric_host_group_exclusion ( + `number` int(10) unsigned NOT NULL AUTO_INCREMENT, + `host_group_name` VARCHAR(50), + PRIMARY KEY(`number`), + UNIQUE KEY `host_group_name_idx` (`host_group_name`) ); CREATE TABLE system_metric_host_exclusion ( - hostGroupName VARCHAR(50), - hostName VARCHAR(50), - PRIMARY KEY(hostGroupName, hostName) + `number` int(10) unsigned NOT NULL AUTO_INCREMENT, + `host_group_name` VARCHAR(50), + `host_name` VARCHAR(50), + PRIMARY KEY(`number`), + UNIQUE KEY `host_group_name_host_name_idx` (`host_group_name`, `host_name`) ); \ No newline at end of file diff --git a/metric-module/metric/src/test/java/com/navercorp/pinpoint/metric/web/service/SystemMetricHostExclusionServiceImplTest.java b/metric-module/metric/src/test/java/com/navercorp/pinpoint/metric/web/service/SystemMetricHostExclusionServiceImplTest.java index c1c419ad0b5b..e1c996f38d5d 100644 --- a/metric-module/metric/src/test/java/com/navercorp/pinpoint/metric/web/service/SystemMetricHostExclusionServiceImplTest.java +++ b/metric-module/metric/src/test/java/com/navercorp/pinpoint/metric/web/service/SystemMetricHostExclusionServiceImplTest.java @@ -59,7 +59,7 @@ public void getEmptyHostGroupExclusionInfoTest() { void getExcludedHostInfoTest() { when(systemMetricHostInfoDao.selectHostList("tenantId", "hostGroupName")).thenReturn(List.of("hostName", "excludedHostName")); when(systemMetricHostExclusionDao.selectExcludedHostNameList("hostGroupName")).thenReturn(List.of("excludedHostName", "anotherExcludedHostName")); - List hostResultList = systemMetricHostExclusionService.getHostInfoList("tenantId", "hostGroupName"); + List hostResultList = systemMetricHostExclusionService.getHostInfoList("tenantId", "hostGroupName", "hostName"); hostResultList.sort(Comparator.comparing(SystemMetricHostInfo::getHostName)); assertThat(hostResultList.get(0).getHostName()).isEqualTo("anotherExcludedHostName"); @@ -70,19 +70,6 @@ void getExcludedHostInfoTest() { assertThat(hostResultList.get(2).isExcluded()).isFalse(); } - @Test - public void deleteUnusedHostExclusionsTest() { - when(systemMetricHostExclusionDao.selectExcludedHostNameList("hostGroupName")).thenReturn(List.of("liveHostName", "deadHostName")); - when(systemMetricHostInfoDao.selectHostList("tenantId", "hostGroupName")).thenReturn(List.of("liveHostName")); - lenient().doNothing().when(systemMetricHostExclusionDao).deleteHostExclusion("hostGroupName", "liveHostName"); - doNothing().when(systemMetricHostExclusionDao).deleteHostExclusion("hostGroupName", "deadHostName"); - - systemMetricHostExclusionService.deleteUnusedHostExclusions("tenantId", "hostGroupName"); - - verify(systemMetricHostExclusionDao, never()).deleteHostExclusion("hostGroupName", "liveHostName"); - verify(systemMetricHostExclusionDao).deleteHostExclusion("hostGroupName", "deadHostName"); - } - @Test public void deleteUnusedGroupExclusionsTest() { when(systemMetricHostExclusionDao.selectExcludedHostGroupNameList()).thenReturn(List.of("liveHostGroupName", "deadHostGroupName1")); diff --git a/metric-module/metric/src/test/java/com/navercorp/pinpoint/metric/web/service/SystemMetricHostInfoServiceImplTest.java b/metric-module/metric/src/test/java/com/navercorp/pinpoint/metric/web/service/SystemMetricHostInfoServiceImplTest.java index 6993739b6da7..4011493b4b3d 100644 --- a/metric-module/metric/src/test/java/com/navercorp/pinpoint/metric/web/service/SystemMetricHostInfoServiceImplTest.java +++ b/metric-module/metric/src/test/java/com/navercorp/pinpoint/metric/web/service/SystemMetricHostInfoServiceImplTest.java @@ -49,7 +49,7 @@ public void hostGroupExclusionTest() { when(systemMetricHostInfoDao.selectHostGroupNameList("tenantId")).thenReturn(hostGroupNames); when(systemMetricHostExclusionDao.selectExcludedHostGroupNameList()).thenReturn(excludedHostGroupNames); - List result = systemMetricHostInfoService.getHostGroupNameList("tenantId", false); + List result = systemMetricHostInfoService.getHostGroupNameList("tenantId"); verify(systemMetricHostInfoDao).selectHostGroupNameList("tenantId"); verify(systemMetricHostExclusionDao).selectExcludedHostGroupNameList(); @@ -68,7 +68,7 @@ public void hostGroupExclusionErrorTest() { when(systemMetricHostInfoDao.selectHostGroupNameList("tenantId")).thenReturn(hostGroupNames); when(systemMetricHostExclusionDao.selectExcludedHostGroupNameList()).thenThrow(new RuntimeException("Test Exception")); - List result = systemMetricHostInfoService.getHostGroupNameList("tenantId", false); + List result = systemMetricHostInfoService.getHostGroupNameList("tenantId"); verify(systemMetricHostInfoDao).selectHostGroupNameList("tenantId"); verify(systemMetricHostExclusionDao).selectExcludedHostGroupNameList(); @@ -83,7 +83,7 @@ public void hostExclusionTest() { when(systemMetricHostInfoDao.selectHostList("tenantId", "hostGroupName")).thenReturn(hostNames); when(systemMetricHostExclusionDao.selectExcludedHostNameList("hostGroupName")).thenReturn(List.of("hostName1", "hostName3")); - List result = systemMetricHostInfoService.getHostList("tenantId", "hostGroupName", false); + List result = systemMetricHostInfoService.getHostList("tenantId", "hostGroupName"); verify(systemMetricHostInfoDao).selectHostList("tenantId", "hostGroupName"); verify(systemMetricHostExclusionDao).selectExcludedHostNameList("hostGroupName"); @@ -98,7 +98,7 @@ public void hostExclusionErrorTest() { when(systemMetricHostInfoDao.selectHostList("tenantId", "hostGroupName")).thenReturn(hostNames); when(systemMetricHostExclusionDao.selectExcludedHostNameList("hostGroupName")).thenThrow(new RuntimeException("Test Exception")); - List result = systemMetricHostInfoService.getHostList("tenantId", "hostGroupName", false); + List result = systemMetricHostInfoService.getHostList("tenantId", "hostGroupName"); verify(systemMetricHostInfoDao).selectHostList("tenantId", "hostGroupName"); verify(systemMetricHostExclusionDao).selectExcludedHostNameList("hostGroupName");