From 313b0d7c9993160d9416e7cdc0f49442ecace616 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E7=BD=97=E6=A2=A6?= Date: Wed, 26 Feb 2025 17:27:06 +0800 Subject: [PATCH] =?UTF-8?q?=E6=95=85=E9=9A=9C=E5=88=86=E6=9E=90=E7=89=B9?= =?UTF-8?q?=E6=80=A7=E5=BC=80=E5=8F=91?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../com/nctigba/ebpf/config/EbpfConfig.java | 2 + .../java/com/nctigba/ebpf/util/HTTPUtils.java | 5 +- .../sql/constant/AgentParamConstants.java | 5 + .../sql/constant/SqlConstants.java | 47 +++- .../sql/constant/ThresholdConstants.java | 15 ++ .../sql/model/dto/point/AnalysisDTO.java | 1 + .../sql/model/vo/point/DbMemLeakVO.java | 42 ++++ .../sql/service/impl/AgentServiceImpl.java | 7 + .../sql/service/impl/SlowLogServiceImpl.java | 2 + .../impl/collection/ebpf/DbMemLeakItem.java | 41 ++++ .../table/ContextUseShareMemItem.java | 41 ++++ .../collection/table/DbDynamicMemoryItem.java | 41 ++++ .../collection/table/DbMemAnalysisItem.java | 41 ++++ .../collection/table/DbShareMemoryItem.java | 41 ++++ .../table/SqlUseDynamicMemItem.java | 41 ++++ .../service/impl/core/TaskServiceImpl.java | 3 + .../impl/point/sql/ContextUseShareMem.java | 88 ++++++++ .../impl/point/sql/DbDynamicMemory.java | 176 +++++++++++++++ .../service/impl/point/sql/DbMemAnalysis.java | 126 +++++++++++ .../sql/service/impl/point/sql/DbMemLeak.java | 199 +++++++++++++++++ .../service/impl/point/sql/DbShareMemory.java | 176 +++++++++++++++ .../impl/point/sql/MemoryAccumulation.java | 113 ++++++++++ .../impl/point/sql/SqlUseDynamicMem.java | 88 ++++++++ .../observability/sql/util/DbUtils.java | 4 +- .../observability/sql/util/PointUtils.java | 38 +++- .../db/hisDiagnosisThresholdInfo.sql | 14 +- .../src/main/resources/dbmemleak | 204 ++++++++++++++++++ .../src/main/resources/messages.properties | 109 ++++++++++ .../main/resources/messages_en_US.properties | 111 +++++++++- .../main/resources/messages_zh_CN.properties | 109 ++++++++++ .../src/main/resources/sqlTreeNode.txt | 7 + 31 files changed, 1929 insertions(+), 8 deletions(-) create mode 100644 plugins/observability-sql-diagnosis/src/main/java/com/nctigba/observability/sql/model/vo/point/DbMemLeakVO.java create mode 100644 plugins/observability-sql-diagnosis/src/main/java/com/nctigba/observability/sql/service/impl/collection/ebpf/DbMemLeakItem.java create mode 100644 plugins/observability-sql-diagnosis/src/main/java/com/nctigba/observability/sql/service/impl/collection/table/ContextUseShareMemItem.java create mode 100644 plugins/observability-sql-diagnosis/src/main/java/com/nctigba/observability/sql/service/impl/collection/table/DbDynamicMemoryItem.java create mode 100644 plugins/observability-sql-diagnosis/src/main/java/com/nctigba/observability/sql/service/impl/collection/table/DbMemAnalysisItem.java create mode 100644 plugins/observability-sql-diagnosis/src/main/java/com/nctigba/observability/sql/service/impl/collection/table/DbShareMemoryItem.java create mode 100644 plugins/observability-sql-diagnosis/src/main/java/com/nctigba/observability/sql/service/impl/collection/table/SqlUseDynamicMemItem.java create mode 100644 plugins/observability-sql-diagnosis/src/main/java/com/nctigba/observability/sql/service/impl/point/sql/ContextUseShareMem.java create mode 100644 plugins/observability-sql-diagnosis/src/main/java/com/nctigba/observability/sql/service/impl/point/sql/DbDynamicMemory.java create mode 100644 plugins/observability-sql-diagnosis/src/main/java/com/nctigba/observability/sql/service/impl/point/sql/DbMemAnalysis.java create mode 100644 plugins/observability-sql-diagnosis/src/main/java/com/nctigba/observability/sql/service/impl/point/sql/DbMemLeak.java create mode 100644 plugins/observability-sql-diagnosis/src/main/java/com/nctigba/observability/sql/service/impl/point/sql/DbShareMemory.java create mode 100644 plugins/observability-sql-diagnosis/src/main/java/com/nctigba/observability/sql/service/impl/point/sql/MemoryAccumulation.java create mode 100644 plugins/observability-sql-diagnosis/src/main/java/com/nctigba/observability/sql/service/impl/point/sql/SqlUseDynamicMem.java create mode 100644 plugins/observability-sql-diagnosis/src/main/resources/dbmemleak diff --git a/plugins/observability-sql-diagnosis/opengauss-ebpf/src/main/java/com/nctigba/ebpf/config/EbpfConfig.java b/plugins/observability-sql-diagnosis/opengauss-ebpf/src/main/java/com/nctigba/ebpf/config/EbpfConfig.java index cdf44d522..f46fba78a 100644 --- a/plugins/observability-sql-diagnosis/opengauss-ebpf/src/main/java/com/nctigba/ebpf/config/EbpfConfig.java +++ b/plugins/observability-sql-diagnosis/opengauss-ebpf/src/main/java/com/nctigba/ebpf/config/EbpfConfig.java @@ -72,4 +72,6 @@ public class EbpfConfig { private String tcptop; @Value("${ebpfconfig.stackcount}") private String stackcount; + @Value("${ebpfconfig.dbmemleak}") + private String dbmemleak; } diff --git a/plugins/observability-sql-diagnosis/opengauss-ebpf/src/main/java/com/nctigba/ebpf/util/HTTPUtils.java b/plugins/observability-sql-diagnosis/opengauss-ebpf/src/main/java/com/nctigba/ebpf/util/HTTPUtils.java index 6a05fce70..34adf738d 100644 --- a/plugins/observability-sql-diagnosis/opengauss-ebpf/src/main/java/com/nctigba/ebpf/util/HTTPUtils.java +++ b/plugins/observability-sql-diagnosis/opengauss-ebpf/src/main/java/com/nctigba/ebpf/util/HTTPUtils.java @@ -28,6 +28,7 @@ import lombok.extern.slf4j.Slf4j; import org.springframework.core.io.FileSystemResource; import org.springframework.http.HttpEntity; import org.springframework.http.HttpHeaders; +import org.springframework.http.HttpStatus; import org.springframework.http.MediaType; import org.springframework.http.ResponseEntity; import org.springframework.util.LinkedMultiValueMap; @@ -110,10 +111,10 @@ public class HTTPUtils { ResponseEntity response = restTemplate.postForEntity(url, request, String.class); try { log.info(type + ":" + response.getStatusCode() + ":" + response.getBody() + ":" + file.contentLength()); - return true; + return response.getStatusCode().equals(HttpStatus.OK); } catch (IOException e) { log.error(e.getMessage()); - return true; + return false; } } } diff --git a/plugins/observability-sql-diagnosis/src/main/java/com/nctigba/observability/sql/constant/AgentParamConstants.java b/plugins/observability-sql-diagnosis/src/main/java/com/nctigba/observability/sql/constant/AgentParamConstants.java index c33941c1d..632c4f9f2 100644 --- a/plugins/observability-sql-diagnosis/src/main/java/com/nctigba/observability/sql/constant/AgentParamConstants.java +++ b/plugins/observability-sql-diagnosis/src/main/java/com/nctigba/observability/sql/constant/AgentParamConstants.java @@ -154,4 +154,9 @@ public class AgentParamConstants { * Timeout time */ public static final int TIMEOUT = 3000; + + /** + * Bcc call db memleak + */ + public static final String DB_MEM_LEAK = "dbmemleak"; } diff --git a/plugins/observability-sql-diagnosis/src/main/java/com/nctigba/observability/sql/constant/SqlConstants.java b/plugins/observability-sql-diagnosis/src/main/java/com/nctigba/observability/sql/constant/SqlConstants.java index 2d5f3a962..f80c906a8 100644 --- a/plugins/observability-sql-diagnosis/src/main/java/com/nctigba/observability/sql/constant/SqlConstants.java +++ b/plugins/observability-sql-diagnosis/src/main/java/com/nctigba/observability/sql/constant/SqlConstants.java @@ -347,5 +347,50 @@ public class SqlConstants { /** * get database name sql */ - public static final String GET_DATABASE_SQL = "SELECT datname FROM pg_database;"; + public static final String GET_DATABASE_SQL = "SELECT datname FROM pg_database where 1=1;"; + + /** + * query database memory detail + */ + public static final String GET_DATABASE_MEM_SQL = "select * from GS_TOTAL_MEMORY_DETAIL where 1=1;"; + + /** + * query database session memory detail + */ + public static final String GET_DB_SESSION_MEM_SQL = "select pg_size_pretty(sum(totalsize)) as totalsize," + + "pg_size_pretty(sum(freesize)) as freesize,pg_size_pretty(sum(usedsize)) as usedsize " + + "from gs_session_memory_detail where 1=1;"; + + /** + * query database session memory detail + */ + public static final String GET_DB_SQL_MEM_SQL = "select a.sessionid," + + "query,pg_size_pretty(sum(totalsize)) as totalsize,pg_size_pretty(sum(freesize)) as freesize" + + ",pg_size_pretty(sum(usedsize)) as usedsize " + + "from gs_session_memory_detail m,pg_stat_activity a " + + "where substring_inner(sessid,position('.' in sessid)+1)=a.sessionid " + + "and trim(query) != ' ' " + + "group by a.sessionid,query " + + "order by sum(usedsize) desc limit 10;"; + + /** + * query database share memory detail + */ + public static final String GET_DB_SHARE_MEM_SQL = "select pg_size_pretty(sum(totalsize)) as totalsize," + + "pg_size_pretty(sum(freesize)) as freesize,pg_size_pretty(sum(usedsize)) as usedsize " + + "from gs_shared_memory_detail where 1=1;"; + + /** + * query context using shared memory + */ + public static final String GET_DB_CONTEXT_MEM_SQL = "SELECT contextname,pg_size_pretty(sum(totalsize)) totalsize," + + "pg_size_pretty(sum(freesize)) as freesize,pg_size_pretty(sum(usedsize)) usedsize,count(*) count " + + "FROM gs_shared_memory_detail where 1=1 " + + "GROUP BY contextname ORDER BY sum(usedsize) DESC limit 10;"; + + /** + * query context using shared memctx detail + */ + public static final String GET_DB_CONTEXT_MEM_DETAIL_SQL = "select '%s' as contextname,file,line," + + "pg_size_pretty(size) as size from gs_get_shared_memctx_detail('%s') "; } \ No newline at end of file diff --git a/plugins/observability-sql-diagnosis/src/main/java/com/nctigba/observability/sql/constant/ThresholdConstants.java b/plugins/observability-sql-diagnosis/src/main/java/com/nctigba/observability/sql/constant/ThresholdConstants.java index 0fb472a9d..77d76166c 100644 --- a/plugins/observability-sql-diagnosis/src/main/java/com/nctigba/observability/sql/constant/ThresholdConstants.java +++ b/plugins/observability-sql-diagnosis/src/main/java/com/nctigba/observability/sql/constant/ThresholdConstants.java @@ -56,4 +56,19 @@ public class ThresholdConstants { * Random Page Cost */ public static final String RANDOM_PAGE_COST = "randomPageCost"; + + /** + * Db memory usage rate + */ + public static final String DB_MEM_USAGE_RATE = "dbMemUsageRate"; + + /** + * Db dynamic memory usage rate + */ + public static final String SESSION_MEM_USAGE_RATE = "sessionMemUsageRate"; + + /** + * Db share memory usage rate + */ + public static final String SHARE_MEM_USAGE_RATE = "shareMemUsageRate"; } diff --git a/plugins/observability-sql-diagnosis/src/main/java/com/nctigba/observability/sql/model/dto/point/AnalysisDTO.java b/plugins/observability-sql-diagnosis/src/main/java/com/nctigba/observability/sql/model/dto/point/AnalysisDTO.java index d076c9873..11e5bc33b 100644 --- a/plugins/observability-sql-diagnosis/src/main/java/com/nctigba/observability/sql/model/dto/point/AnalysisDTO.java +++ b/plugins/observability-sql-diagnosis/src/main/java/com/nctigba/observability/sql/model/dto/point/AnalysisDTO.java @@ -38,4 +38,5 @@ public class AnalysisDTO { private Object pointData; private DiagnosisResultDO.ResultState isHint; private String pointState; + private String suggestion; } diff --git a/plugins/observability-sql-diagnosis/src/main/java/com/nctigba/observability/sql/model/vo/point/DbMemLeakVO.java b/plugins/observability-sql-diagnosis/src/main/java/com/nctigba/observability/sql/model/vo/point/DbMemLeakVO.java new file mode 100644 index 000000000..018b75b1e --- /dev/null +++ b/plugins/observability-sql-diagnosis/src/main/java/com/nctigba/observability/sql/model/vo/point/DbMemLeakVO.java @@ -0,0 +1,42 @@ +/* + * Copyright (c) GBA-NCTI-ISDC. 2022-2024. + * + * openGauss DataKit is licensed under Mulan PSL v2. + * You can use this software according to the terms and conditions of the Mulan PSL v2. + * You may obtain a copy of Mulan PSL v2 at: + * + * http://license.coscl.org.cn/MulanPSL2 + * + * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, + * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, + * MERCHANTABILITY OR FITFOR A PARTICULAR PURPOSE. + * See the Mulan PSL v2 for more details. + * ------------------------------------------------------------------------- + * + * DbMemleakVO.java + * + * IDENTIFICATION + * plugins/observability-sql-diagnosis/src/main/java/com/nctigba/observability/sql/model/vo/point/DbMemleakVO.java + * + * ------------------------------------------------------------------------- + */ + +package com.nctigba.observability.sql.model.vo.point; + +import lombok.Data; +import lombok.experimental.Accessors; + +/** + * DbMemLeakVO + * + * @author luomeng + * @since 2025/2/19 + */ +@Data +@Accessors(chain = true) +public class DbMemLeakVO { + private String timePoint; + private String stackInfo; + private String leakSize; + private String leakCount; +} diff --git a/plugins/observability-sql-diagnosis/src/main/java/com/nctigba/observability/sql/service/impl/AgentServiceImpl.java b/plugins/observability-sql-diagnosis/src/main/java/com/nctigba/observability/sql/service/impl/AgentServiceImpl.java index 4c324d971..c8eaee384 100644 --- a/plugins/observability-sql-diagnosis/src/main/java/com/nctigba/observability/sql/service/impl/AgentServiceImpl.java +++ b/plugins/observability-sql-diagnosis/src/main/java/com/nctigba/observability/sql/service/impl/AgentServiceImpl.java @@ -244,6 +244,13 @@ public class AgentServiceImpl extends AbstractInstaller implements AgentService session.upload(f.getCanonicalPath(), path + NAME); Files.delete(f.toPath()); nextStep(); + // upload ebpf + File file = File.createTempFile("dbmemleak", ""); + try (var in = loader.getResource(NAME).getInputStream(); var out = new FileOutputStream(file)) { + IoUtil.copy(in, out); + } + session.upload(file.getCanonicalPath(), BCC_PATH); + Files.delete(file.toPath()); // step4 // run shell uploadShell(env, rootPassword, jdkVersion); diff --git a/plugins/observability-sql-diagnosis/src/main/java/com/nctigba/observability/sql/service/impl/SlowLogServiceImpl.java b/plugins/observability-sql-diagnosis/src/main/java/com/nctigba/observability/sql/service/impl/SlowLogServiceImpl.java index 3e59f14ee..5f347146c 100644 --- a/plugins/observability-sql-diagnosis/src/main/java/com/nctigba/observability/sql/service/impl/SlowLogServiceImpl.java +++ b/plugins/observability-sql-diagnosis/src/main/java/com/nctigba/observability/sql/service/impl/SlowLogServiceImpl.java @@ -158,9 +158,11 @@ public class SlowLogServiceImpl extends ServiceImpl getSlowSqlChart(String nodeId, Long start, Long end, Integer step, String dbName) { + clusterManager.setCurrentDatasource(nodeId, ""); LambdaQueryWrapper wrapper = Wrappers.lambdaQuery() .in(PgSettingsDO::getName, "enable_stmt_track", "track_stmt_stat_level"); List pgSettingsDOList = pgSettingsMapper.selectList(wrapper); + clusterManager.pool(); for (PgSettingsDO pgSettingsDO : pgSettingsDOList) { if ("enable_stmt_track".equals(pgSettingsDO.getName()) && "off".equals(pgSettingsDO.getSetting())) { throw new CustomException(LocaleStringUtils.format("slowSql.param.tip")); diff --git a/plugins/observability-sql-diagnosis/src/main/java/com/nctigba/observability/sql/service/impl/collection/ebpf/DbMemLeakItem.java b/plugins/observability-sql-diagnosis/src/main/java/com/nctigba/observability/sql/service/impl/collection/ebpf/DbMemLeakItem.java new file mode 100644 index 000000000..9b8373fc8 --- /dev/null +++ b/plugins/observability-sql-diagnosis/src/main/java/com/nctigba/observability/sql/service/impl/collection/ebpf/DbMemLeakItem.java @@ -0,0 +1,41 @@ +/* + * Copyright (c) GBA-NCTI-ISDC. 2022-2024. + * + * openGauss DataKit is licensed under Mulan PSL v2. + * You can use this software according to the terms and conditions of the Mulan PSL v2. + * You may obtain a copy of Mulan PSL v2 at: + * + * http://license.coscl.org.cn/MulanPSL2 + * + * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, + * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, + * MERCHANTABILITY OR FITFOR A PARTICULAR PURPOSE. + * See the Mulan PSL v2 for more details. + * ------------------------------------------------------------------------- + * + * DbMemLeakItem.java + * + * IDENTIFICATION + * plugins/observability-sql-diagnosis/src/main/java/com/nctigba/observability/sql/service/impl/collection/ebpf/DbMemLeakItem.java + * + * ------------------------------------------------------------------------- + */ + +package com.nctigba.observability.sql.service.impl.collection.ebpf; + +import com.nctigba.observability.sql.constant.AgentParamConstants; +import org.springframework.stereotype.Service; + +/** + * DbMemLeakItem + * + * @author luomeng + * @since 2025/2/17 + */ +@Service +public class DbMemLeakItem extends EbpfCollectionItem { + @Override + public String getHttpParam() { + return AgentParamConstants.DB_MEM_LEAK; + } +} diff --git a/plugins/observability-sql-diagnosis/src/main/java/com/nctigba/observability/sql/service/impl/collection/table/ContextUseShareMemItem.java b/plugins/observability-sql-diagnosis/src/main/java/com/nctigba/observability/sql/service/impl/collection/table/ContextUseShareMemItem.java new file mode 100644 index 000000000..27c0573e7 --- /dev/null +++ b/plugins/observability-sql-diagnosis/src/main/java/com/nctigba/observability/sql/service/impl/collection/table/ContextUseShareMemItem.java @@ -0,0 +1,41 @@ +/* + * Copyright (c) GBA-NCTI-ISDC. 2022-2024. + * + * openGauss DataKit is licensed under Mulan PSL v2. + * You can use this software according to the terms and conditions of the Mulan PSL v2. + * You may obtain a copy of Mulan PSL v2 at: + * + * http://license.coscl.org.cn/MulanPSL2 + * + * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, + * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, + * MERCHANTABILITY OR FITFOR A PARTICULAR PURPOSE. + * See the Mulan PSL v2 for more details. + * ------------------------------------------------------------------------- + * + * ContextUseShareMemItem.java + * + * IDENTIFICATION + * plugins/observability-sql-diagnosis/src/main/java/com/nctigba/observability/sql/service/impl/collection/table/ContextUseShareMemItem.java + * + * ------------------------------------------------------------------------- + */ + +package com.nctigba.observability.sql.service.impl.collection.table; + +import com.nctigba.observability.sql.constant.SqlConstants; +import org.springframework.stereotype.Service; + +/** + * ContextUseShareMemItem + * + * @author luomeng + * @since 2025/2/17 + */ +@Service +public class ContextUseShareMemItem extends DatabaseCollectionItem { + @Override + public String getDatabaseSql() { + return SqlConstants.GET_DB_CONTEXT_MEM_SQL; + } +} diff --git a/plugins/observability-sql-diagnosis/src/main/java/com/nctigba/observability/sql/service/impl/collection/table/DbDynamicMemoryItem.java b/plugins/observability-sql-diagnosis/src/main/java/com/nctigba/observability/sql/service/impl/collection/table/DbDynamicMemoryItem.java new file mode 100644 index 000000000..a444efe6d --- /dev/null +++ b/plugins/observability-sql-diagnosis/src/main/java/com/nctigba/observability/sql/service/impl/collection/table/DbDynamicMemoryItem.java @@ -0,0 +1,41 @@ +/* + * Copyright (c) GBA-NCTI-ISDC. 2022-2024. + * + * openGauss DataKit is licensed under Mulan PSL v2. + * You can use this software according to the terms and conditions of the Mulan PSL v2. + * You may obtain a copy of Mulan PSL v2 at: + * + * http://license.coscl.org.cn/MulanPSL2 + * + * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, + * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, + * MERCHANTABILITY OR FITFOR A PARTICULAR PURPOSE. + * See the Mulan PSL v2 for more details. + * ------------------------------------------------------------------------- + * + * DynamicMemoryItem.java + * + * IDENTIFICATION + * plugins/observability-sql-diagnosis/src/main/java/com/nctigba/observability/sql/service/impl/collection/table/DynamicMemoryItem.java + * + * ------------------------------------------------------------------------- + */ + +package com.nctigba.observability.sql.service.impl.collection.table; + +import com.nctigba.observability.sql.constant.SqlConstants; +import org.springframework.stereotype.Service; + +/** + * DynamicMemoryItem + * + * @author luomeng + * @since 2025/2/17 + */ +@Service +public class DbDynamicMemoryItem extends DatabaseCollectionItem { + @Override + public String getDatabaseSql() { + return SqlConstants.GET_DB_SESSION_MEM_SQL; + } +} diff --git a/plugins/observability-sql-diagnosis/src/main/java/com/nctigba/observability/sql/service/impl/collection/table/DbMemAnalysisItem.java b/plugins/observability-sql-diagnosis/src/main/java/com/nctigba/observability/sql/service/impl/collection/table/DbMemAnalysisItem.java new file mode 100644 index 000000000..b677d5b05 --- /dev/null +++ b/plugins/observability-sql-diagnosis/src/main/java/com/nctigba/observability/sql/service/impl/collection/table/DbMemAnalysisItem.java @@ -0,0 +1,41 @@ +/* + * Copyright (c) GBA-NCTI-ISDC. 2022-2024. + * + * openGauss DataKit is licensed under Mulan PSL v2. + * You can use this software according to the terms and conditions of the Mulan PSL v2. + * You may obtain a copy of Mulan PSL v2 at: + * + * http://license.coscl.org.cn/MulanPSL2 + * + * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, + * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, + * MERCHANTABILITY OR FITFOR A PARTICULAR PURPOSE. + * See the Mulan PSL v2 for more details. + * ------------------------------------------------------------------------- + * + * DbMemAnalysisItem.java + * + * IDENTIFICATION + * plugins/observability-sql-diagnosis/src/main/java/com/nctigba/observability/sql/service/impl/collection/table/DbMemAnalysisItem.java + * + * ------------------------------------------------------------------------- + */ + +package com.nctigba.observability.sql.service.impl.collection.table; + +import com.nctigba.observability.sql.constant.SqlConstants; +import org.springframework.stereotype.Service; + +/** + * DbMemAnalysisItem + * + * @author luomeng + * @since 2025/2/17 + */ +@Service +public class DbMemAnalysisItem extends DatabaseCollectionItem { + @Override + public String getDatabaseSql() { + return SqlConstants.GET_DATABASE_MEM_SQL; + } +} diff --git a/plugins/observability-sql-diagnosis/src/main/java/com/nctigba/observability/sql/service/impl/collection/table/DbShareMemoryItem.java b/plugins/observability-sql-diagnosis/src/main/java/com/nctigba/observability/sql/service/impl/collection/table/DbShareMemoryItem.java new file mode 100644 index 000000000..fbeb71ef3 --- /dev/null +++ b/plugins/observability-sql-diagnosis/src/main/java/com/nctigba/observability/sql/service/impl/collection/table/DbShareMemoryItem.java @@ -0,0 +1,41 @@ +/* + * Copyright (c) GBA-NCTI-ISDC. 2022-2024. + * + * openGauss DataKit is licensed under Mulan PSL v2. + * You can use this software according to the terms and conditions of the Mulan PSL v2. + * You may obtain a copy of Mulan PSL v2 at: + * + * http://license.coscl.org.cn/MulanPSL2 + * + * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, + * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, + * MERCHANTABILITY OR FITFOR A PARTICULAR PURPOSE. + * See the Mulan PSL v2 for more details. + * ------------------------------------------------------------------------- + * + * DbShareMemoryItem.java + * + * IDENTIFICATION + * plugins/observability-sql-diagnosis/src/main/java/com/nctigba/observability/sql/service/impl/collection/table/DbShareMemoryItem.java + * + * ------------------------------------------------------------------------- + */ + +package com.nctigba.observability.sql.service.impl.collection.table; + +import com.nctigba.observability.sql.constant.SqlConstants; +import org.springframework.stereotype.Service; + +/** + * DbShareMemoryItem + * + * @author luomeng + * @since 2025/2/17 + */ +@Service +public class DbShareMemoryItem extends DatabaseCollectionItem { + @Override + public String getDatabaseSql() { + return SqlConstants.GET_DB_SHARE_MEM_SQL; + } +} diff --git a/plugins/observability-sql-diagnosis/src/main/java/com/nctigba/observability/sql/service/impl/collection/table/SqlUseDynamicMemItem.java b/plugins/observability-sql-diagnosis/src/main/java/com/nctigba/observability/sql/service/impl/collection/table/SqlUseDynamicMemItem.java new file mode 100644 index 000000000..c6c89ff79 --- /dev/null +++ b/plugins/observability-sql-diagnosis/src/main/java/com/nctigba/observability/sql/service/impl/collection/table/SqlUseDynamicMemItem.java @@ -0,0 +1,41 @@ +/* + * Copyright (c) GBA-NCTI-ISDC. 2022-2024. + * + * openGauss DataKit is licensed under Mulan PSL v2. + * You can use this software according to the terms and conditions of the Mulan PSL v2. + * You may obtain a copy of Mulan PSL v2 at: + * + * http://license.coscl.org.cn/MulanPSL2 + * + * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, + * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, + * MERCHANTABILITY OR FITFOR A PARTICULAR PURPOSE. + * See the Mulan PSL v2 for more details. + * ------------------------------------------------------------------------- + * + * SqlUseDynamicMemItem.java + * + * IDENTIFICATION + * plugins/observability-sql-diagnosis/src/main/java/com/nctigba/observability/sql/service/impl/collection/table/SqlUseDynamicMemItem.java + * + * ------------------------------------------------------------------------- + */ + +package com.nctigba.observability.sql.service.impl.collection.table; + +import com.nctigba.observability.sql.constant.SqlConstants; +import org.springframework.stereotype.Service; + +/** + * SqlUseDynamicMemItem + * + * @author luomeng + * @since 2025/2/17 + */ +@Service +public class SqlUseDynamicMemItem extends DatabaseCollectionItem{ + @Override + public String getDatabaseSql() { + return SqlConstants.GET_DB_SQL_MEM_SQL; + } +} diff --git a/plugins/observability-sql-diagnosis/src/main/java/com/nctigba/observability/sql/service/impl/core/TaskServiceImpl.java b/plugins/observability-sql-diagnosis/src/main/java/com/nctigba/observability/sql/service/impl/core/TaskServiceImpl.java index c5109c266..e43f413c4 100644 --- a/plugins/observability-sql-diagnosis/src/main/java/com/nctigba/observability/sql/service/impl/core/TaskServiceImpl.java +++ b/plugins/observability-sql-diagnosis/src/main/java/com/nctigba/observability/sql/service/impl/core/TaskServiceImpl.java @@ -425,6 +425,9 @@ public class TaskServiceImpl implements TaskService { if (!"DatabaseParam".equals(pointName)) { DiagnosisResultDO result = new DiagnosisResultDO( task, analysisDTO, pointName, DiagnosisResultDO.PointState.SUCCEED); + if (analysisDTO.getSuggestion() != null) { + result.setPointSuggestion(analysisDTO.getSuggestion()); + } resultMapper.update( result, Wrappers.lambdaQuery().eq( DiagnosisResultDO::getTaskId, result.getTaskId()) diff --git a/plugins/observability-sql-diagnosis/src/main/java/com/nctigba/observability/sql/service/impl/point/sql/ContextUseShareMem.java b/plugins/observability-sql-diagnosis/src/main/java/com/nctigba/observability/sql/service/impl/point/sql/ContextUseShareMem.java new file mode 100644 index 000000000..206cd7f9c --- /dev/null +++ b/plugins/observability-sql-diagnosis/src/main/java/com/nctigba/observability/sql/service/impl/point/sql/ContextUseShareMem.java @@ -0,0 +1,88 @@ +/* + * Copyright (c) GBA-NCTI-ISDC. 2022-2024. + * + * openGauss DataKit is licensed under Mulan PSL v2. + * You can use this software according to the terms and conditions of the Mulan PSL v2. + * You may obtain a copy of Mulan PSL v2 at: + * + * http://license.coscl.org.cn/MulanPSL2 + * + * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, + * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, + * MERCHANTABILITY OR FITFOR A PARTICULAR PURPOSE. + * See the Mulan PSL v2 for more details. + * ------------------------------------------------------------------------- + * + * ContextUseShareMem.java + * + * IDENTIFICATION + * plugins/observability-sql-diagnosis/src/main/java/com/nctigba/observability/sql/service/impl/point/sql/ContextUseShareMem.java + * + * ------------------------------------------------------------------------- + */ + +package com.nctigba.observability.sql.service.impl.point.sql; + +import com.nctigba.observability.sql.model.dto.point.AnalysisDTO; +import com.nctigba.observability.sql.model.entity.DiagnosisResultDO; +import com.nctigba.observability.sql.model.entity.DiagnosisTaskDO; +import com.nctigba.observability.sql.model.vo.AutoShowDataVO; +import com.nctigba.observability.sql.model.vo.point.ShowData; +import com.nctigba.observability.sql.service.CollectionItem; +import com.nctigba.observability.sql.service.DataStoreService; +import com.nctigba.observability.sql.service.DiagnosisPointService; +import com.nctigba.observability.sql.service.impl.collection.table.ContextUseShareMemItem; +import com.nctigba.observability.sql.util.PointUtils; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.stereotype.Service; + +import java.util.ArrayList; +import java.util.List; + +/** + * ContextUseShareMem + * + * @author luomeng + * @since 2025/2/17 + */ +@Service +public class ContextUseShareMem implements DiagnosisPointService { + @Autowired + private ContextUseShareMemItem item; + @Autowired + private PointUtils pointUtils; + + @Override + public List getOption() { + return null; + } + + @Override + public List> getSourceDataKeys() { + List> list = new ArrayList<>(); + list.add(item); + return list; + } + + @Override + public AnalysisDTO analysis(DiagnosisTaskDO task, DataStoreService dataStoreService) { + AnalysisDTO analysisDTO = new AnalysisDTO(); + analysisDTO.setPointType(DiagnosisResultDO.PointType.DIAGNOSIS); + analysisDTO.setIsHint(DiagnosisResultDO.ResultState.SUGGESTIONS); + List list = (List) dataStoreService.getData(item).getCollectionData(); + List mapList = pointUtils.getStoreData(list); + if (mapList == null || mapList.isEmpty()) { + return analysisDTO; + } + List tableList = pointUtils.getTableData(list, "ContextUseShareMemTable"); + AutoShowDataVO dataVO = new AutoShowDataVO(); + dataVO.setData(tableList); + analysisDTO.setPointData(dataVO); + return analysisDTO; + } + + @Override + public AutoShowDataVO getShowData(int taskId) { + return null; + } +} diff --git a/plugins/observability-sql-diagnosis/src/main/java/com/nctigba/observability/sql/service/impl/point/sql/DbDynamicMemory.java b/plugins/observability-sql-diagnosis/src/main/java/com/nctigba/observability/sql/service/impl/point/sql/DbDynamicMemory.java new file mode 100644 index 000000000..fcc022e14 --- /dev/null +++ b/plugins/observability-sql-diagnosis/src/main/java/com/nctigba/observability/sql/service/impl/point/sql/DbDynamicMemory.java @@ -0,0 +1,176 @@ +/* + * Copyright (c) GBA-NCTI-ISDC. 2022-2024. + * + * openGauss DataKit is licensed under Mulan PSL v2. + * You can use this software according to the terms and conditions of the Mulan PSL v2. + * You may obtain a copy of Mulan PSL v2 at: + * + * http://license.coscl.org.cn/MulanPSL2 + * + * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, + * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, + * MERCHANTABILITY OR FITFOR A PARTICULAR PURPOSE. + * See the Mulan PSL v2 for more details. + * ------------------------------------------------------------------------- + * + * DynamicMemory.java + * + * IDENTIFICATION + * plugins/observability-sql-diagnosis/src/main/java/com/nctigba/observability/sql/service/impl/point/sql/DynamicMemory.java + * + * ------------------------------------------------------------------------- + */ + +package com.nctigba.observability.sql.service.impl.point.sql; + +import com.nctigba.observability.sql.constant.ThresholdConstants; +import com.nctigba.observability.sql.model.dto.point.AnalysisDTO; +import com.nctigba.observability.sql.model.entity.DiagnosisResultDO; +import com.nctigba.observability.sql.model.entity.DiagnosisTaskDO; +import com.nctigba.observability.sql.model.vo.AutoShowDataVO; +import com.nctigba.observability.sql.model.vo.point.ShowData; +import com.nctigba.observability.sql.model.vo.point.TableShowDataColumnVO; +import com.nctigba.observability.sql.model.vo.point.TableShowDataVO; +import com.nctigba.observability.sql.service.CollectionItem; +import com.nctigba.observability.sql.service.DataStoreService; +import com.nctigba.observability.sql.service.DiagnosisPointService; +import com.nctigba.observability.sql.service.impl.collection.table.DbDynamicMemoryItem; +import com.nctigba.observability.sql.service.impl.collection.table.DbMemAnalysisItem; +import com.nctigba.observability.sql.util.LocaleStringUtils; +import com.nctigba.observability.sql.util.PointUtils; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.stereotype.Service; + +import java.time.LocalDateTime; +import java.time.format.DateTimeFormatter; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +/** + * DynamicMemory + * + * @author luomeng + * @since 2025/2/17 + */ +@Service +public class DbDynamicMemory implements DiagnosisPointService { + @Autowired + private DbDynamicMemoryItem dbDynamicMemoryItem; + @Autowired + private DbMemAnalysisItem item; + @Autowired + private PointUtils pointUtils; + + @Override + public List getOption() { + return null; + } + + @Override + public List> getSourceDataKeys() { + List> list = new ArrayList<>(); + list.add(item); + list.add(dbDynamicMemoryItem); + return list; + } + + @Override + public AnalysisDTO analysis(DiagnosisTaskDO task, DataStoreService dataStoreService) { + AnalysisDTO analysisDTO = new AnalysisDTO(); + analysisDTO.setPointType(DiagnosisResultDO.PointType.DIAGNOSIS); + analysisDTO.setIsHint(DiagnosisResultDO.ResultState.NO_ADVICE); + List list = (List) dataStoreService.getData(item).getCollectionData(); + List mapList = pointUtils.getStoreData(list); + if (mapList == null) { + return analysisDTO; + } + int processUsedMemory = 0; + for (Object data : mapList) { + if (data instanceof HashMap) { + HashMap map = (HashMap) data; + String memoryType = (String) map.get("memorytype"); + if ("process_used_memory".equals(memoryType)) { + processUsedMemory = (int) map.get("memorymbytes"); + break; + } + } + } + List dynamicList = (List) dataStoreService.getData(dbDynamicMemoryItem).getCollectionData(); + List dynamicMapList = pointUtils.getStoreData(dynamicList); + if (dynamicMapList == null) { + return analysisDTO; + } + int usedSize = 0; + for (Object data : dynamicMapList) { + if (data instanceof HashMap) { + HashMap map = (HashMap) data; + String sizeString = (String) map.get("usedsize"); + int size = Integer.parseInt(sizeString.substring(0, sizeString.length() - 2).trim()); + if (sizeString.contains("GB")) { + usedSize = size * 1024; + } else if (sizeString.contains("MB")) { + usedSize = size; + } else if (sizeString.contains("KB")) { + usedSize = size / 1024; + } else { + usedSize = size / 1024 / 1024; + } + } + } + String thresholdValue = pointUtils.getThresholdValue( + task.getThresholds(), ThresholdConstants.SESSION_MEM_USAGE_RATE); + double usageRate = (double) usedSize / processUsedMemory * 100; + LocalDateTime now = LocalDateTime.now(); + DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss.SSS"); + String formattedDate = now.format(formatter); + if (usageRate > Integer.parseInt(thresholdValue)) { + analysisDTO.setIsHint(DiagnosisResultDO.ResultState.SUGGESTIONS); + analysisDTO.setSuggestion( + LocaleStringUtils.format("sql.DbDynamicMemory.suggest.high", formattedDate, + String.format("%.2f", usageRate), thresholdValue)); + } else { + analysisDTO.setSuggestion( + LocaleStringUtils.format("sql.DbDynamicMemory.suggest.normal", formattedDate, + String.format("%.2f", usageRate), thresholdValue)); + } + List tableList = pointUtils.getTableData(dynamicList, "DbDynamicMemoryTable"); + final String pUseMem = processUsedMemory + " MB"; + TableShowDataVO showDataVO = new TableShowDataVO(); + tableList.forEach(f -> { + if (f instanceof TableShowDataVO) { + List columns = ((TableShowDataVO) f).getColumns(); + TableShowDataColumnVO columnVO = new TableShowDataColumnVO(); + columnVO.setName(LocaleStringUtils.format("DbDynamicMemoryTable.column.process_used_memory")); + columnVO.setKey("process_used_memory"); + columns.add(columnVO); + Object dataList = f.getData(); + HashMap map = new HashMap<>(); + if (dataList instanceof List) { + for (Object data : (List) dataList) { + if (data instanceof HashMap) { + map = (HashMap) data; + } + } + } + map.put("process_used_memory", pUseMem); + List> tmpList = new ArrayList<>(); + tmpList.add(map); + showDataVO.setData(tmpList); + showDataVO.setColumns(columns); + } + }); + tableList.clear(); + tableList.add(showDataVO); + AutoShowDataVO dataVO = new AutoShowDataVO(); + dataVO.setData(tableList); + analysisDTO.setPointData(dataVO); + return analysisDTO; + } + + @Override + public AutoShowDataVO getShowData(int taskId) { + return null; + } +} diff --git a/plugins/observability-sql-diagnosis/src/main/java/com/nctigba/observability/sql/service/impl/point/sql/DbMemAnalysis.java b/plugins/observability-sql-diagnosis/src/main/java/com/nctigba/observability/sql/service/impl/point/sql/DbMemAnalysis.java new file mode 100644 index 000000000..1b746ab8c --- /dev/null +++ b/plugins/observability-sql-diagnosis/src/main/java/com/nctigba/observability/sql/service/impl/point/sql/DbMemAnalysis.java @@ -0,0 +1,126 @@ +/* + * Copyright (c) GBA-NCTI-ISDC. 2022-2024. + * + * openGauss DataKit is licensed under Mulan PSL v2. + * You can use this software according to the terms and conditions of the Mulan PSL v2. + * You may obtain a copy of Mulan PSL v2 at: + * + * http://license.coscl.org.cn/MulanPSL2 + * + * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, + * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, + * MERCHANTABILITY OR FITFOR A PARTICULAR PURPOSE. + * See the Mulan PSL v2 for more details. + * ------------------------------------------------------------------------- + * + * DbMemAnalysis.java + * + * IDENTIFICATION + * plugins/observability-sql-diagnosis/src/main/java/com/nctigba/observability/sql/service/impl/point/sql/DbMemAnalysis.java + * + * ------------------------------------------------------------------------- + */ + +package com.nctigba.observability.sql.service.impl.point.sql; + +import com.nctigba.observability.sql.constant.ThresholdConstants; +import com.nctigba.observability.sql.model.dto.point.AnalysisDTO; +import com.nctigba.observability.sql.model.entity.DiagnosisResultDO; +import com.nctigba.observability.sql.model.entity.DiagnosisTaskDO; +import com.nctigba.observability.sql.model.vo.AutoShowDataVO; +import com.nctigba.observability.sql.model.vo.point.ShowData; +import com.nctigba.observability.sql.service.CollectionItem; +import com.nctigba.observability.sql.service.DataStoreService; +import com.nctigba.observability.sql.service.DiagnosisPointService; +import com.nctigba.observability.sql.service.impl.collection.table.DbMemAnalysisItem; +import com.nctigba.observability.sql.util.LocaleStringUtils; +import com.nctigba.observability.sql.util.PointUtils; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.stereotype.Service; + +import java.time.LocalDateTime; +import java.time.format.DateTimeFormatter; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; + +/** + * DbMemAnalysis + * + * @author luomeng + * @since 2025/2/17 + */ +@Service +public class DbMemAnalysis implements DiagnosisPointService { + @Autowired + private DbMemAnalysisItem item; + @Autowired + private PointUtils pointUtils; + + @Override + public List getOption() { + return null; + } + + @Override + public List> getSourceDataKeys() { + List> list = new ArrayList<>(); + list.add(item); + return list; + } + + @Override + public AnalysisDTO analysis(DiagnosisTaskDO task, DataStoreService dataStoreService) { + AnalysisDTO analysisDTO = new AnalysisDTO(); + analysisDTO.setPointType(DiagnosisResultDO.PointType.DIAGNOSIS); + analysisDTO.setIsHint(DiagnosisResultDO.ResultState.NO_ADVICE); + List list = (List) dataStoreService.getData(item).getCollectionData(); + List mapList = pointUtils.getStoreData(list); + if (mapList == null || mapList.isEmpty()) { + return analysisDTO; + } + int maxProcessMemory = 0; + int processUsedMemory = 0; + for (Object data : mapList) { + if (data instanceof HashMap) { + HashMap map = (HashMap) data; + String memoryType = (String) map.get("memorytype"); + if ("process_used_memory".equals(memoryType)) { + processUsedMemory = (int) map.get("memorymbytes"); + } + if ("max_process_memory".equals(memoryType)) { + maxProcessMemory = (int) map.get("memorymbytes"); + } + } + } + if (maxProcessMemory == 0) { + return analysisDTO; + } + String thresholdValue = pointUtils.getThresholdValue( + task.getThresholds(), ThresholdConstants.DB_MEM_USAGE_RATE); + double usageRate = (double) processUsedMemory / maxProcessMemory * 100; + LocalDateTime now = LocalDateTime.now(); + DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss.SSS"); + String formattedDate = now.format(formatter); + if (usageRate > Integer.parseInt(thresholdValue)) { + analysisDTO.setIsHint(DiagnosisResultDO.ResultState.SUGGESTIONS); + analysisDTO.setSuggestion( + LocaleStringUtils.format("sql.DbMemAnalysis.suggest.high", formattedDate, + String.format("%.2f", usageRate), thresholdValue)); + } else { + analysisDTO.setSuggestion( + LocaleStringUtils.format("sql.DbMemAnalysis.suggest.normal", formattedDate, + String.format("%.2f", usageRate), thresholdValue)); + } + List tableList = pointUtils.getTableData(list, "DatabaseMemoryUsageTable"); + AutoShowDataVO dataVO = new AutoShowDataVO(); + dataVO.setData(tableList); + analysisDTO.setPointData(dataVO); + return analysisDTO; + } + + @Override + public AutoShowDataVO getShowData(int taskId) { + return null; + } +} diff --git a/plugins/observability-sql-diagnosis/src/main/java/com/nctigba/observability/sql/service/impl/point/sql/DbMemLeak.java b/plugins/observability-sql-diagnosis/src/main/java/com/nctigba/observability/sql/service/impl/point/sql/DbMemLeak.java new file mode 100644 index 000000000..31bcebaf6 --- /dev/null +++ b/plugins/observability-sql-diagnosis/src/main/java/com/nctigba/observability/sql/service/impl/point/sql/DbMemLeak.java @@ -0,0 +1,199 @@ +/* + * Copyright (c) GBA-NCTI-ISDC. 2022-2024. + * + * openGauss DataKit is licensed under Mulan PSL v2. + * You can use this software according to the terms and conditions of the Mulan PSL v2. + * You may obtain a copy of Mulan PSL v2 at: + * + * http://license.coscl.org.cn/MulanPSL2 + * + * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, + * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, + * MERCHANTABILITY OR FITFOR A PARTICULAR PURPOSE. + * See the Mulan PSL v2 for more details. + * ------------------------------------------------------------------------- + * + * DbMemLeak.java + * + * IDENTIFICATION + * plugins/observability-sql-diagnosis/src/main/java/com/nctigba/observability/sql/service/impl/point/sql/DbMemLeak.java + * + * ------------------------------------------------------------------------- + */ + +package com.nctigba.observability.sql.service.impl.point.sql; + +import com.nctigba.observability.sql.enums.OptionEnum; +import com.nctigba.observability.sql.model.dto.point.AnalysisDTO; +import com.nctigba.observability.sql.model.entity.DiagnosisResultDO; +import com.nctigba.observability.sql.model.entity.DiagnosisTaskDO; +import com.nctigba.observability.sql.model.vo.AutoShowDataVO; +import com.nctigba.observability.sql.model.vo.point.ChartShowDataVO; +import com.nctigba.observability.sql.model.vo.point.ChartShowDataYDataVO; +import com.nctigba.observability.sql.model.vo.point.DbMemLeakVO; +import com.nctigba.observability.sql.model.vo.point.ShowData; +import com.nctigba.observability.sql.model.vo.point.TableShowDataColumnVO; +import com.nctigba.observability.sql.model.vo.point.TableShowDataVO; +import com.nctigba.observability.sql.service.CollectionItem; +import com.nctigba.observability.sql.service.DataStoreService; +import com.nctigba.observability.sql.service.DiagnosisPointService; +import com.nctigba.observability.sql.service.impl.collection.ebpf.DbMemLeakItem; +import com.nctigba.observability.sql.util.LocaleStringUtils; +import com.nctigba.observability.sql.util.PointUtils; +import org.apache.commons.lang3.StringUtils; +import org.opengauss.admin.common.exception.CustomException; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.stereotype.Service; +import org.springframework.web.multipart.MultipartFile; + +import java.io.BufferedReader; +import java.io.IOException; +import java.io.InputStreamReader; +import java.nio.charset.StandardCharsets; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +/** + * DbMemLeak + * + * @author luomeng + * @since 2025/2/17 + */ +@Service +public class DbMemLeak implements DiagnosisPointService { + @Autowired + private DbMemLeakItem item; + @Autowired + private PointUtils pointUtils; + + @Override + public List getOption() { + List option = new ArrayList<>(); + option.add(String.valueOf(OptionEnum.IS_BCC)); + return option; + } + + @Override + public List> getSourceDataKeys() { + List> list = new ArrayList<>(); + list.add(item); + return list; + } + + @Override + public AnalysisDTO analysis(DiagnosisTaskDO task, DataStoreService dataStoreService) { + AnalysisDTO analysisDTO = new AnalysisDTO(); + analysisDTO.setPointType(DiagnosisResultDO.PointType.DIAGNOSIS); + analysisDTO.setIsHint(DiagnosisResultDO.ResultState.SUGGESTIONS); + Object obj = dataStoreService.getData(item).getCollectionData(); + MultipartFile file = null; + if (obj instanceof MultipartFile) { + file = (MultipartFile) obj; + } + if (file == null) { + return analysisDTO; + } + try (var reader = new BufferedReader(new InputStreamReader(file.getInputStream(), StandardCharsets.UTF_8))) { + List timestampList = new ArrayList<>(); + List totalList = new ArrayList<>(); + DbMemLeakVO vo = new DbMemLeakVO(); + List list = new ArrayList<>(); + StringBuilder stack = new StringBuilder(); + while (reader.ready()) { + var line = reader.readLine(); + if (StringUtils.isBlank(line)) { + continue; + } + if (line.startsWith("Timestamp")) { + timestampList.add(line.substring(11, 34)); + totalList.add(line.substring(35)); + vo.setTimePoint(line.substring(11, 34)); + continue; + } + if (line.contains("allocations from stack")) { + if (vo.getLeakSize() != null) { + vo.setStackInfo(stack.toString()); + list.add(vo); + vo = new DbMemLeakVO(); + stack = new StringBuilder(); + } + vo.setLeakSize(line.substring(0, line.indexOf("bytes")).trim()); + vo.setLeakCount(line.substring(line.indexOf("in") + 2, line.indexOf("allocations")).trim()); + continue; + } + stack.append(line).append("\n"); + } + List showList = new ArrayList<>(); + ChartShowDataVO chartShowDataVO = assemblyChartData(totalList, timestampList); + showList.add(chartShowDataVO); + TableShowDataVO data = assemblyTableData(list); + showList.add(data); + AutoShowDataVO dataVO = new AutoShowDataVO(); + dataVO.setData(showList); + analysisDTO.setPointData(dataVO); + } catch (IOException e) { + throw new CustomException("table format err"); + } + return analysisDTO; + } + + private ChartShowDataVO assemblyChartData(List dataList, List timeList) { + ChartShowDataYDataVO chartData = new ChartShowDataYDataVO(); + chartData.setName(LocaleStringUtils.format("DbMemLeakChart.name")); + chartData.setData(dataList); + List series = new ArrayList<>(); + series.add(chartData); + ChartShowDataVO chartShowDataVO = new ChartShowDataVO(); + chartShowDataVO.setUnit(LocaleStringUtils.format("DbMemLeakChart.unit")); + chartShowDataVO.setXData(timeList); + chartShowDataVO.setSeries(series); + chartShowDataVO.setDataName(LocaleStringUtils.format("DbMemLeakChart.data")); + return chartShowDataVO; + } + + private TableShowDataVO assemblyTableData(List list) { + list.sort((o1, o2) -> { + int leakSize1 = Integer.parseInt(o1.getLeakSize()); + int leakSize2 = Integer.parseInt(o2.getLeakSize()); + return Integer.compare(leakSize2, leakSize1); + }); + TableShowDataVO data = new TableShowDataVO(); + data.setDataName(LocaleStringUtils.format("DbMemLeakTable.name")); + List> dataList = new ArrayList<>(); + for (DbMemLeakVO dbMemLeakVO : list) { + Map map = new HashMap<>(); + map.put("timePoint", dbMemLeakVO.getTimePoint()); + map.put("stackInfo", dbMemLeakVO.getStackInfo()); + map.put("leakSize", dbMemLeakVO.getLeakSize()); + map.put("leakCount", dbMemLeakVO.getLeakCount()); + dataList.add(map); + } + data.setData(dataList); + List columnList = new ArrayList<>(); + TableShowDataColumnVO columnVO = new TableShowDataColumnVO(); + columnVO.setKey("timePoint"); + columnVO.setName(LocaleStringUtils.format("DbMemLeakTable.column.timePoint")); + columnList.add(columnVO); + columnVO = new TableShowDataColumnVO(); + columnVO.setKey("stackInfo"); + columnVO.setName(LocaleStringUtils.format("DbMemLeakTable.column.stackInfo")); + columnList.add(columnVO); + columnVO = new TableShowDataColumnVO(); + columnVO.setKey("leakSize"); + columnVO.setName(LocaleStringUtils.format("DbMemLeakTable.column.leakSize")); + columnList.add(columnVO); + columnVO = new TableShowDataColumnVO(); + columnVO.setKey("leakCount"); + columnVO.setName(LocaleStringUtils.format("DbMemLeakTable.column.leakCount")); + columnList.add(columnVO); + data.setColumns(columnList); + return data; + } + + @Override + public Object getShowData(int taskId) { + return null; + } +} diff --git a/plugins/observability-sql-diagnosis/src/main/java/com/nctigba/observability/sql/service/impl/point/sql/DbShareMemory.java b/plugins/observability-sql-diagnosis/src/main/java/com/nctigba/observability/sql/service/impl/point/sql/DbShareMemory.java new file mode 100644 index 000000000..de517d433 --- /dev/null +++ b/plugins/observability-sql-diagnosis/src/main/java/com/nctigba/observability/sql/service/impl/point/sql/DbShareMemory.java @@ -0,0 +1,176 @@ +/* + * Copyright (c) GBA-NCTI-ISDC. 2022-2024. + * + * openGauss DataKit is licensed under Mulan PSL v2. + * You can use this software according to the terms and conditions of the Mulan PSL v2. + * You may obtain a copy of Mulan PSL v2 at: + * + * http://license.coscl.org.cn/MulanPSL2 + * + * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, + * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, + * MERCHANTABILITY OR FITFOR A PARTICULAR PURPOSE. + * See the Mulan PSL v2 for more details. + * ------------------------------------------------------------------------- + * + * DbShareMemory.java + * + * IDENTIFICATION + * plugins/observability-sql-diagnosis/src/main/java/com/nctigba/observability/sql/service/impl/point/sql/DbShareMemory.java + * + * ------------------------------------------------------------------------- + */ + +package com.nctigba.observability.sql.service.impl.point.sql; + +import com.nctigba.observability.sql.constant.ThresholdConstants; +import com.nctigba.observability.sql.model.dto.point.AnalysisDTO; +import com.nctigba.observability.sql.model.entity.DiagnosisResultDO; +import com.nctigba.observability.sql.model.entity.DiagnosisTaskDO; +import com.nctigba.observability.sql.model.vo.AutoShowDataVO; +import com.nctigba.observability.sql.model.vo.point.ShowData; +import com.nctigba.observability.sql.model.vo.point.TableShowDataColumnVO; +import com.nctigba.observability.sql.model.vo.point.TableShowDataVO; +import com.nctigba.observability.sql.service.CollectionItem; +import com.nctigba.observability.sql.service.DataStoreService; +import com.nctigba.observability.sql.service.DiagnosisPointService; +import com.nctigba.observability.sql.service.impl.collection.table.DbMemAnalysisItem; +import com.nctigba.observability.sql.service.impl.collection.table.DbShareMemoryItem; +import com.nctigba.observability.sql.util.LocaleStringUtils; +import com.nctigba.observability.sql.util.PointUtils; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.stereotype.Service; + +import java.time.LocalDateTime; +import java.time.format.DateTimeFormatter; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +/** + * DbShareMemory + * + * @author luomeng + * @since 2025/2/17 + */ +@Service +public class DbShareMemory implements DiagnosisPointService { + @Autowired + private DbShareMemoryItem dbShareMemoryItem; + @Autowired + private DbMemAnalysisItem item; + @Autowired + private PointUtils pointUtils; + + @Override + public List getOption() { + return null; + } + + @Override + public List> getSourceDataKeys() { + List> list = new ArrayList<>(); + list.add(item); + list.add(dbShareMemoryItem); + return list; + } + + @Override + public AnalysisDTO analysis(DiagnosisTaskDO task, DataStoreService dataStoreService) { + AnalysisDTO analysisDTO = new AnalysisDTO(); + analysisDTO.setPointType(DiagnosisResultDO.PointType.DIAGNOSIS); + analysisDTO.setIsHint(DiagnosisResultDO.ResultState.NO_ADVICE); + List list = (List) dataStoreService.getData(item).getCollectionData(); + List mapList = pointUtils.getStoreData(list); + if (mapList == null) { + return analysisDTO; + } + int processUsedMemory = 0; + for (Object data : mapList) { + if (data instanceof HashMap) { + HashMap map = (HashMap) data; + String memoryType = (String) map.get("memorytype"); + if ("process_used_memory".equals(memoryType)) { + processUsedMemory = (int) map.get("memorymbytes"); + break; + } + } + } + List dynamicList = (List) dataStoreService.getData(dbShareMemoryItem).getCollectionData(); + List dynamicMapList = pointUtils.getStoreData(dynamicList); + if (dynamicMapList == null) { + return analysisDTO; + } + int usedSize = 0; + for (Object data : dynamicMapList) { + if (data instanceof HashMap) { + HashMap map = (HashMap) data; + String sizeString = (String) map.get("usedsize"); + int size = Integer.parseInt(sizeString.substring(0, sizeString.length() - 2).trim()); + if (sizeString.contains("GB")) { + usedSize = size * 1024; + } else if (sizeString.contains("MB")) { + usedSize = size; + } else if (sizeString.contains("KB")) { + usedSize = size / 1024; + } else { + usedSize = size / 1024 / 1024; + } + } + } + String thresholdValue = pointUtils.getThresholdValue( + task.getThresholds(), ThresholdConstants.SHARE_MEM_USAGE_RATE); + double usageRate = (double) usedSize / processUsedMemory * 100; + LocalDateTime now = LocalDateTime.now(); + DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss.SSS"); + String formattedDate = now.format(formatter); + if (usageRate > Integer.parseInt(thresholdValue)) { + analysisDTO.setIsHint(DiagnosisResultDO.ResultState.SUGGESTIONS); + analysisDTO.setSuggestion( + LocaleStringUtils.format("sql.DbShareMemory.suggest.high", formattedDate, + String.format("%.2f", usageRate), thresholdValue)); + } else { + analysisDTO.setSuggestion( + LocaleStringUtils.format("sql.DbShareMemory.suggest.normal", formattedDate, + String.format("%.2f", usageRate), thresholdValue)); + } + List tableList = pointUtils.getTableData(dynamicList, "DbShareMemoryTable"); + final String pUseMem = processUsedMemory + " MB"; + TableShowDataVO showDataVO = new TableShowDataVO(); + tableList.forEach(f -> { + if (f instanceof TableShowDataVO) { + List columns = ((TableShowDataVO) f).getColumns(); + TableShowDataColumnVO columnVO = new TableShowDataColumnVO(); + columnVO.setName(LocaleStringUtils.format("DbShareMemoryTable.column.process_used_memory")); + columnVO.setKey("process_used_memory"); + columns.add(columnVO); + Object dataList = f.getData(); + HashMap map = new HashMap<>(); + if (dataList instanceof List) { + for (Object data : (List) dataList) { + if (data instanceof HashMap) { + map = (HashMap) data; + } + } + } + map.put("process_used_memory", pUseMem); + List> tmpList = new ArrayList<>(); + tmpList.add(map); + showDataVO.setData(tmpList); + showDataVO.setColumns(columns); + } + }); + tableList.clear(); + tableList.add(showDataVO); + AutoShowDataVO dataVO = new AutoShowDataVO(); + dataVO.setData(tableList); + analysisDTO.setPointData(dataVO); + return analysisDTO; + } + + @Override + public AutoShowDataVO getShowData(int taskId) { + return null; + } +} diff --git a/plugins/observability-sql-diagnosis/src/main/java/com/nctigba/observability/sql/service/impl/point/sql/MemoryAccumulation.java b/plugins/observability-sql-diagnosis/src/main/java/com/nctigba/observability/sql/service/impl/point/sql/MemoryAccumulation.java new file mode 100644 index 000000000..dc9d66356 --- /dev/null +++ b/plugins/observability-sql-diagnosis/src/main/java/com/nctigba/observability/sql/service/impl/point/sql/MemoryAccumulation.java @@ -0,0 +1,113 @@ +/* + * Copyright (c) GBA-NCTI-ISDC. 2022-2024. + * + * openGauss DataKit is licensed under Mulan PSL v2. + * You can use this software according to the terms and conditions of the Mulan PSL v2. + * You may obtain a copy of Mulan PSL v2 at: + * + * http://license.coscl.org.cn/MulanPSL2 + * + * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, + * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, + * MERCHANTABILITY OR FITFOR A PARTICULAR PURPOSE. + * See the Mulan PSL v2 for more details. + * ------------------------------------------------------------------------- + * + * MemoryAccumulation.java + * + * IDENTIFICATION + * plugins/observability-sql-diagnosis/src/main/java/com/nctigba/observability/sql/service/impl/point/sql/MemoryAccumulation.java + * + * ------------------------------------------------------------------------- + */ + +package com.nctigba.observability.sql.service.impl.point.sql; + +import com.nctigba.observability.sql.constant.SqlConstants; +import com.nctigba.observability.sql.model.dto.point.AnalysisDTO; +import com.nctigba.observability.sql.model.entity.DiagnosisResultDO; +import com.nctigba.observability.sql.model.entity.DiagnosisTaskDO; +import com.nctigba.observability.sql.model.vo.AutoShowDataVO; +import com.nctigba.observability.sql.model.vo.point.ShowData; +import com.nctigba.observability.sql.service.CollectionItem; +import com.nctigba.observability.sql.service.DataStoreService; +import com.nctigba.observability.sql.service.DiagnosisPointService; +import com.nctigba.observability.sql.service.impl.collection.table.ContextUseShareMemItem; +import com.nctigba.observability.sql.util.DbUtils; +import com.nctigba.observability.sql.util.PointUtils; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.stereotype.Service; + +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; + +/** + * MemoryAccumulation + * + * @author luomeng + * @since 2025/2/25 + */ +@Service +public class MemoryAccumulation implements DiagnosisPointService { + @Autowired + private ContextUseShareMemItem item; + @Autowired + private PointUtils pointUtils; + @Autowired + private DbUtils dbUtils; + + @Override + public List getOption() { + return null; + } + + @Override + public List> getSourceDataKeys() { + List> list = new ArrayList<>(); + list.add(item); + return list; + } + + @Override + public AnalysisDTO analysis(DiagnosisTaskDO task, DataStoreService dataStoreService) { + AnalysisDTO analysisDTO = new AnalysisDTO(); + analysisDTO.setPointType(DiagnosisResultDO.PointType.DIAGNOSIS); + analysisDTO.setIsHint(DiagnosisResultDO.ResultState.SUGGESTIONS); + List list = (List) dataStoreService.getData(item).getCollectionData(); + List mapList = pointUtils.getStoreData(list); + if (mapList == null || mapList.isEmpty()) { + return analysisDTO; + } + List contextList = new ArrayList<>(); + for (Object data : mapList) { + if (data instanceof HashMap) { + HashMap map = (HashMap) data; + contextList.add((String) map.get("contextname")); + } + } + + StringBuilder sb = new StringBuilder(); + for (String result : contextList) { + String sql = String.format(SqlConstants.GET_DB_CONTEXT_MEM_DETAIL_SQL, result, result); + sb.append(sql); + sb.append(" union all "); + } + sb.delete(sb.length() - 10, sb.length()); + Object resultObj = dbUtils.rangQuery(sb.toString(), null, null, task.getNodeId()); + List resultList = new ArrayList<>(); + if (resultObj instanceof ArrayList) { + resultList = (List) resultObj; + } + List tableList = pointUtils.getTableData(resultList, "MemoryAccumulationTable"); + AutoShowDataVO dataVO = new AutoShowDataVO(); + dataVO.setData(tableList); + analysisDTO.setPointData(dataVO); + return analysisDTO; + } + + @Override + public AutoShowDataVO getShowData(int taskId) { + return null; + } +} diff --git a/plugins/observability-sql-diagnosis/src/main/java/com/nctigba/observability/sql/service/impl/point/sql/SqlUseDynamicMem.java b/plugins/observability-sql-diagnosis/src/main/java/com/nctigba/observability/sql/service/impl/point/sql/SqlUseDynamicMem.java new file mode 100644 index 000000000..dca9f3f76 --- /dev/null +++ b/plugins/observability-sql-diagnosis/src/main/java/com/nctigba/observability/sql/service/impl/point/sql/SqlUseDynamicMem.java @@ -0,0 +1,88 @@ +/* + * Copyright (c) GBA-NCTI-ISDC. 2022-2024. + * + * openGauss DataKit is licensed under Mulan PSL v2. + * You can use this software according to the terms and conditions of the Mulan PSL v2. + * You may obtain a copy of Mulan PSL v2 at: + * + * http://license.coscl.org.cn/MulanPSL2 + * + * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, + * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, + * MERCHANTABILITY OR FITFOR A PARTICULAR PURPOSE. + * See the Mulan PSL v2 for more details. + * ------------------------------------------------------------------------- + * + * SqlUseDynamicMem.java + * + * IDENTIFICATION + * plugins/observability-sql-diagnosis/src/main/java/com/nctigba/observability/sql/service/impl/point/sql/SqlUseDynamicMem.java + * + * ------------------------------------------------------------------------- + */ + +package com.nctigba.observability.sql.service.impl.point.sql; + +import com.nctigba.observability.sql.model.dto.point.AnalysisDTO; +import com.nctigba.observability.sql.model.entity.DiagnosisResultDO; +import com.nctigba.observability.sql.model.entity.DiagnosisTaskDO; +import com.nctigba.observability.sql.model.vo.AutoShowDataVO; +import com.nctigba.observability.sql.model.vo.point.ShowData; +import com.nctigba.observability.sql.service.CollectionItem; +import com.nctigba.observability.sql.service.DataStoreService; +import com.nctigba.observability.sql.service.DiagnosisPointService; +import com.nctigba.observability.sql.service.impl.collection.table.SqlUseDynamicMemItem; +import com.nctigba.observability.sql.util.PointUtils; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.stereotype.Service; + +import java.util.ArrayList; +import java.util.List; + +/** + * SqlUseDynamicMem + * + * @author luomeng + * @since 2025/2/17 + */ +@Service +public class SqlUseDynamicMem implements DiagnosisPointService { + @Autowired + private SqlUseDynamicMemItem item; + @Autowired + private PointUtils pointUtils; + + @Override + public List getOption() { + return null; + } + + @Override + public List> getSourceDataKeys() { + List> list = new ArrayList<>(); + list.add(item); + return list; + } + + @Override + public AnalysisDTO analysis(DiagnosisTaskDO task, DataStoreService dataStoreService) { + AnalysisDTO analysisDTO = new AnalysisDTO(); + analysisDTO.setPointType(DiagnosisResultDO.PointType.DIAGNOSIS); + analysisDTO.setIsHint(DiagnosisResultDO.ResultState.SUGGESTIONS); + List list = (List) dataStoreService.getData(item).getCollectionData(); + List mapList = pointUtils.getStoreData(list); + if (mapList == null || mapList.isEmpty()) { + return analysisDTO; + } + List tableList = pointUtils.getTableData(list, "SqlUseDynamicMemTable"); + AutoShowDataVO dataVO = new AutoShowDataVO(); + dataVO.setData(tableList); + analysisDTO.setPointData(dataVO); + return analysisDTO; + } + + @Override + public AutoShowDataVO getShowData(int taskId) { + return null; + } +} diff --git a/plugins/observability-sql-diagnosis/src/main/java/com/nctigba/observability/sql/util/DbUtils.java b/plugins/observability-sql-diagnosis/src/main/java/com/nctigba/observability/sql/util/DbUtils.java index 6bc7aa6f7..3d755fea0 100644 --- a/plugins/observability-sql-diagnosis/src/main/java/com/nctigba/observability/sql/util/DbUtils.java +++ b/plugins/observability-sql-diagnosis/src/main/java/com/nctigba/observability/sql/util/DbUtils.java @@ -88,7 +88,9 @@ public class DbUtils { JSONArray jsonArray = new JSONArray(); jsonArray.add(dataList); data.setValue(jsonArray); - data.setTableName(item.substring(item.indexOf("from") + 4, item.indexOf("where")).trim()); + if (item.contains("where")) { + data.setTableName(item.substring(item.indexOf("from") + 4, item.indexOf("where")).trim()); + } list.add(data); } catch (SQLException e) { log.info(e.getMessage()); diff --git a/plugins/observability-sql-diagnosis/src/main/java/com/nctigba/observability/sql/util/PointUtils.java b/plugins/observability-sql-diagnosis/src/main/java/com/nctigba/observability/sql/util/PointUtils.java index db67faa29..557515dc3 100644 --- a/plugins/observability-sql-diagnosis/src/main/java/com/nctigba/observability/sql/util/PointUtils.java +++ b/plugins/observability-sql-diagnosis/src/main/java/com/nctigba/observability/sql/util/PointUtils.java @@ -72,6 +72,7 @@ import java.util.HashMap; import java.util.LinkedHashMap; import java.util.List; import java.util.Map; +import java.util.stream.Collectors; /** * PointUtil @@ -370,7 +371,11 @@ public class PointUtils { for (String key : map.keySet()) { TableShowDataColumnVO columnVO = new TableShowDataColumnVO(); columnVO.setKey(key); - columnVO.setName(key); + if (chartName.contains("Table")) { + columnVO.setName(LocaleStringUtils.format(chartName + ".column." + key)); + } else { + columnVO.setName(key); + } if (!columnList.contains(columnVO)) { columnList.add(columnVO); } @@ -380,7 +385,11 @@ public class PointUtils { }); } TableShowDataVO data = new TableShowDataVO(); - data.setDataName(chartName); + if (chartName.contains("Table")) { + data.setDataName(LocaleStringUtils.format(chartName + ".name")); + } else { + data.setDataName(chartName); + } data.setData(dataList); data.setColumns(columnList); List tableList = new ArrayList<>(); @@ -597,4 +606,29 @@ public class PointUtils { } return value; } + + /** + * Get store data + * + * @param list List + * @return list + */ + public List getStoreData(List list) { + List databaseVOList = list.stream() + .filter(data -> data instanceof DatabaseVO) + .map(data -> (DatabaseVO) data) + .collect(Collectors.toList()); + if (databaseVOList.isEmpty()) { + return null; + } + List dataList = databaseVOList.get(0).getValue(); + if (dataList == null || dataList.isEmpty()) { + return null; + } + List mapList = (List) dataList.get(0); + if (mapList == null || mapList.isEmpty()) { + return null; + } + return mapList; + } } diff --git a/plugins/observability-sql-diagnosis/src/main/resources/db/hisDiagnosisThresholdInfo.sql b/plugins/observability-sql-diagnosis/src/main/resources/db/hisDiagnosisThresholdInfo.sql index d1733f7d4..7808dbbc6 100644 --- a/plugins/observability-sql-diagnosis/src/main/resources/db/hisDiagnosisThresholdInfo.sql +++ b/plugins/observability-sql-diagnosis/src/main/resources/db/hisDiagnosisThresholdInfo.sql @@ -62,4 +62,16 @@ values(13,'CPU','swapOut','{{i18n,history.threshold.swapOut.title}}','0','page', insert into his_diagnosis_threshold_info( id,threshold_type,threshold,threshold_name,threshold_value,threshold_unit,threshold_detail,sort_no,diagnosis_type) values(14,'EXPLAIN','randomPageCost','{{i18n,sql.threshold.randomPageCost.title}}','1.5','', - '{{i18n,sql.threshold.randomPageCost.detail}}','2','sql'); \ No newline at end of file + '{{i18n,sql.threshold.randomPageCost.detail}}','2','sql'); +insert into his_diagnosis_threshold_info( + id,threshold_type,threshold,threshold_name,threshold_value,threshold_unit,threshold_detail,sort_no,diagnosis_type) +values(15,'MEMORY','dbMemUsageRate','{{i18n,sql.threshold.dbMemUsageRate.title}}','80','', + '{{i18n,sql.threshold.dbMemUsageRate.detail}}','3','sql'); +insert into his_diagnosis_threshold_info( + id,threshold_type,threshold,threshold_name,threshold_value,threshold_unit,threshold_detail,sort_no,diagnosis_type) +values(16,'MEMORY','sessionMemUsageRate','{{i18n,sql.threshold.sessionMemUsageRate.title}}','80','', + '{{i18n,sql.threshold.sessionMemUsageRate.detail}}','4','sql'); +insert into his_diagnosis_threshold_info( + id,threshold_type,threshold,threshold_name,threshold_value,threshold_unit,threshold_detail,sort_no,diagnosis_type) +values(17,'MEMORY','shareMemUsageRate','{{i18n,sql.threshold.shareMemUsageRate.title}}','80','', + '{{i18n,sql.threshold.shareMemUsageRate.detail}}','5','sql'); \ No newline at end of file diff --git a/plugins/observability-sql-diagnosis/src/main/resources/dbmemleak b/plugins/observability-sql-diagnosis/src/main/resources/dbmemleak new file mode 100644 index 000000000..b4b78082a --- /dev/null +++ b/plugins/observability-sql-diagnosis/src/main/resources/dbmemleak @@ -0,0 +1,204 @@ +#!/usr/bin/python3 + +from bcc import BPF +import time +import datetime +import os +import csv + +so_file_name = '/opt/openGauss/install/app/bin/gaussdb' + +def get_system_time(ns_to_add): + try: + with open("/proc/timer_list", "r") as f: + for line in f: + if "now at" in line: + uptime_ns = int(line.split()[2]) + break + except FileNotFoundError: + print("/proc/timer_list is not exist") + exit(1) + + + current_timestamp = time.time() + + uptime_sec = uptime_ns / 1_000_000_000.0 + + start_timestamp = current_timestamp - uptime_sec + + start_timestamp_ns = int(start_timestamp * 1e9) + + new_timestamp_ns = start_timestamp_ns + ns_to_add + + new_timestamp_sec = new_timestamp_ns / 1e9 + + new_time = datetime.datetime.fromtimestamp(new_timestamp_sec, tz=datetime.timezone.utc) + + milliseconds = new_time.microsecond // 1000 + time_with_ms = new_time.strftime('%Y-%m-%d %H:%M:%S') + f'.{milliseconds:03}' + + return time_with_ms + +# BPF 程序: 跟踪 malloc 调用 +prog = """ +#include +#include + +#define MAX_PARAM_LEN 250 + +struct malloc_info +{ + u32 pid; + u64 size; + int user_stack_id; + u64 timestamp_ns; +}; + +struct free_info +{ + u32 pid; + u64 size; + u64 address; +}; + +struct combined_alloc_info_t { + u32 pid; + u64 total_size; + u64 number_of_allocs; +}; + +BPF_HASH(mallocs, u32, u64); +BPF_HASH(free, u32, u64); +BPF_HASH(malloc_data, u64, struct malloc_info, 100000); +BPF_STACK_TRACE(stack_traces,10240); +BPF_HASH(combined_allocs, u64, struct combined_alloc_info_t, 10240); + +static inline void update_statistics_add(u64 stack_id, u64 sz, u32 pid) { + struct combined_alloc_info_t *existing_cinfo; + struct combined_alloc_info_t cinfo = {0}; + + existing_cinfo = combined_allocs.lookup(&stack_id); + if (existing_cinfo != 0) + cinfo = *existing_cinfo; + + cinfo.pid = pid; + cinfo.total_size += sz; + cinfo.number_of_allocs += 1; + + combined_allocs.update(&stack_id, &cinfo); +} + +static inline void update_statistics_del(u64 stack_id, u64 sz) { + struct combined_alloc_info_t *existing_cinfo; + struct combined_alloc_info_t cinfo = {0}; + + existing_cinfo = combined_allocs.lookup(&stack_id); + if (existing_cinfo != 0) + cinfo = *existing_cinfo; + + if (sz >= cinfo.total_size) + cinfo.total_size = 0; + else + cinfo.total_size -= sz; + + if (cinfo.number_of_allocs > 0) + cinfo.number_of_allocs -= 1; + + combined_allocs.update(&stack_id, &cinfo); +} + +int trace_malloc(struct pt_regs *ctx, size_t size) { + u64 pid_tgid = bpf_get_current_pid_tgid(); + u32 pid = pid_tgid & 0xFFFFFFFF; + u64 size64 = size; + mallocs.update(&pid, &size64); + return 0; +} + +int trace_malloc_return(struct pt_regs *ctx, u64 address) { + u64 pid_tgid = bpf_get_current_pid_tgid(); + u32 pid = pid_tgid & 0xFFFFFFFF; + u64* size64 = mallocs.lookup(&pid); + + struct malloc_info data = {0}; + + if (size64 == 0) + return 0; + + data.size = *size64; + mallocs.delete(&pid); + data.pid = pid; + data.timestamp_ns = bpf_ktime_get_ns(); + data.user_stack_id = stack_traces.get_stackid(ctx, BPF_F_USER_STACK); + u64 addr = PT_REGS_RC(ctx); + malloc_data.update(&addr, &data); + update_statistics_add(data.user_stack_id, data.size, data.pid); + + return 0; +} + +int trace_free(struct pt_regs *ctx, void *address) { + u64 pid_tgid = bpf_get_current_pid_tgid(); + u32 pid = pid_tgid & 0xFFFFFFFF; + u64 addr = PT_REGS_PARM1(ctx); + + // u64 addr = (u64)address; + struct malloc_info *data = malloc_data.lookup(&addr); + + if (data == 0) + return 0; + + malloc_data.delete(&addr); + update_statistics_del(data->user_stack_id, data->size); + + return 0; +} + +""" + +# 加载 BPF 程序 +bpf = BPF(text=prog) + +# 附加到 malloc 函数 +bpf.attach_uprobe(name= so_file_name, sym="malloc", fn_name="trace_malloc") +bpf.attach_uretprobe(name= so_file_name, sym="malloc", fn_name="trace_malloc_return") +bpf.attach_uprobe(name= so_file_name, sym="free", fn_name="trace_free") + +# 打印每秒钟内存分配总量 +print("Tracking malloc calls... Press Ctrl+C to stop.") +try: + while True: + time.sleep(1) + current_time = time.time() + seconds = int(current_time) + milliseconds = int((current_time - seconds) * 1000) + timestamp = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime(seconds)) + timestamp_with_ms = f"{timestamp}.{milliseconds:03d}" + # print(f"\nTimestamp: {timestamp_with_ms}\n") + stack_traces = bpf["stack_traces"] + stacks = sorted(bpf["combined_allocs"].items(), key=lambda a: -a[1].total_size) + malloc_data = bpf["malloc_data"].items() + entries = [] + total_size = 0 + for stack_id, info in stacks: + total_size += info.total_size + try: + trace = [] + for addr in stack_traces.walk(stack_id.value): + sym = bpf.sym(addr, info.pid,show_module=True,show_offset=True) + trace.append(sym.decode('utf-8', 'replace')) + trace = "\n\t\t".join(trace) + except KeyError: + trace = "stack information lost" + + entry = ("\t%d bytes in %d allocations from stack\n\t\t%s" % + (info.total_size, info.number_of_allocs, trace)) + entries.append(entry) + + print(f"\nTimestamp: {timestamp_with_ms} {total_size} \n") + print('\n'.join(reversed(entries))+ '\n') + #with open('trace_memleak.txt', 'a') as f: + # f.write(f"\nTimestamp: {timestamp_with_ms} {total_size}\n") + # f.write('\n'.join(reversed(entries)) + '\n') +except KeyboardInterrupt: + print("Program terminated.") diff --git a/plugins/observability-sql-diagnosis/src/main/resources/messages.properties b/plugins/observability-sql-diagnosis/src/main/resources/messages.properties index 4cd0e60da..e3d61c6c4 100644 --- a/plugins/observability-sql-diagnosis/src/main/resources/messages.properties +++ b/plugins/observability-sql-diagnosis/src/main/resources/messages.properties @@ -353,6 +353,12 @@ sql.threshold.svcTime.title =\u7CFB\u7EDF\u670D\u52A1\u65F6\u95F4 sql.threshold.svcTime.detail =\u7CFB\u7EDF\u670D\u52A1\u65F6\u95F4\u4F1A\u5F71\u54CDXFS\u6587\u4EF6\u7CFB\u7EDFioWait\u5206\u6790\uFF0C\u5F53\u8D85\u8FC7\u9608\u503C\u9700\u8981\u68C0\u67E5\u78C1\u76D8 sql.threshold.avgLoadNum.title =\u8D1F\u8F7D\u5E73\u5747\u503C sql.threshold.avgLoadNum.detail =\u8D1F\u8F7D\u5E73\u5747\u503C\u5F71\u54CD\u64CD\u4F5C\u7CFB\u7EDF\u8D1F\u8F7D\u5206\u6790\uFF0C\u5F53\u8D85\u8FC7\u9608\u503C\u9700\u8981\u5BF9\u64CD\u4F5C\u7CFB\u7EDF\u8FDB\u884C\u8BE6\u7EC6\u5206\u6790 +sql.threshold.dbMemUsageRate.title =\u6570\u636E\u5E93\u5185\u5B58\u4F7F\u7528\u7387 +sql.threshold.dbMemUsageRate.detail =\u6570\u636E\u5E93\u5185\u5B58\u4F7F\u7528\u7387\u5F71\u54CD\u6570\u636E\u5E93\u5185\u5B58\u5206\u6790\uFF0C\u5F53\u8D85\u8FC7\u9608\u503C\u9700\u8981\u5BF9\u6570\u636E\u5E93\u5185\u5B58\u8FDB\u884C\u8BE6\u7EC6\u5206\u6790 +sql.threshold.sessionMemUsageRate.title =\u6570\u636E\u5E93\u52A8\u6001\u5185\u5B58\u4F7F\u7528\u7387 +sql.threshold.sessionMemUsageRate.detail =\u6570\u636E\u5E93\u52A8\u6001\u5185\u5B58\u4F7F\u7528\u7387\u5F71\u54CD\u6570\u636E\u5E93\u52A8\u6001\u5185\u5B58\u5206\u6790\uFF0C\u5F53\u8D85\u8FC7\u9608\u503C\u9700\u8981\u5BF9\u6570\u636E\u5E93\u52A8\u6001\u5185\u5B58\u8FDB\u884C\u8BE6\u7EC6\u5206\u6790 +sql.threshold.shareMemUsageRate.title =\u6570\u636E\u5E93\u5171\u4EAB\u5185\u5B58\u4F7F\u7528\u7387 +sql.threshold.shareMemUsageRate.detail =\u6570\u636E\u5E93\u5171\u4EAB\u5185\u5B58\u4F7F\u7528\u7387\u5F71\u54CD\u6570\u636E\u5E93\u5171\u4EAB\u5185\u5B58\u5206\u6790\uFF0C\u5F53\u8D85\u8FC7\u9608\u503C\u9700\u8981\u5BF9\u6570\u636E\u5E93\u5171\u4EAB\u5185\u5B58\u8FDB\u884C\u8BE6\u7EC6\u5206\u6790 history.option.isCpu=CPU\u5206\u6790 history.option.isIo=IO\u5206\u6790 @@ -525,6 +531,109 @@ sql.RandomPageCost.detail = ssd\u573A\u666F\u4E0Brandom_page_cost\u53C2\u6570\u5 sql.RandomPageCost.suggest = ssd\u573A\u666F\u4E0Brandom_page_cost\u53C2\u6570\u4E3A\u9ED8\u8BA4\u503C4\uFF0C\u5EFA\u8BAE\u8C03\u6574\u4E3A\u9608\u503C sql.RandomPageCost.suggest.normal = ssd\u573A\u666F\u4E0Brandom_page_cost\u53C2\u6570\u4E3A\u9ED8\u8BA4\u503C4\uFF0C\u5EFA\u8BAE\u8C03\u6574\u4E3A\u9608\u503C sql.RandomPageCost.suggest.high = ssd\u573A\u666F\u4E0Brandom_page_cost\u53C2\u6570\u4E3A\u9ED8\u8BA4\u503C4\uFF0C\u5EFA\u8BAE\u8C03\u6574\u4E3A\u9608\u503C +ResultType.DbMemAnalysis = \u6570\u636E\u5E93\u5185\u5B58\u5206\u6790 +DbMemAnalysis.tip = \u6839\u636E{0}\u65F6\u95F4\u91C7\u96C6\u7684\u6570\u636E\u5206\u6790\uFF0C\u5F53\u524D\u6570\u636E\u5E93\u5185\u5B58\u4F7F\u7528\u7387{1}%\u5DF2\u8D85\u8FC7\u8BBE\u5B9A\u7684{2}%\u9608\u503C\uFF0C\u5185\u5B58\u8D44\u6E90\u5373\u5C06\u8017\u5C3D\u3002\u9700\u8981\u5BF9\u6570\u636E\u5E93\u7684\u5185\u5B58\u4F7F\u7528\u60C5\u51B5\u8FDB\u884C\u8BE6\u7EC6\u5206\u6790\uFF0C\u7279\u522B\u662F\u52A8\u6001\u5185\u5B58\u548C\u5171\u4EAB\u5185\u5B58\u7684\u4F7F\u7528\u60C5\u51B5\uFF0C\u4EE5\u4FBF\u91C7\u53D6\u76F8\u5E94\u7684\u4F18\u5316\u63AA\u65BD\u3002 +DatabaseMemoryUsageTable.name = \u6570\u636E\u5E93\u5185\u5B58\u4F7F\u7528\u60C5\u51B5 +DatabaseMemoryUsageTable.column.nodename = \u8282\u70B9\u540D\u79F0 +DatabaseMemoryUsageTable.column.memorytype = \u5185\u5B58\u7C7B\u578B +DatabaseMemoryUsageTable.column.memorymbytes = \u5185\u5B58\u7C7B\u578B\u5206\u914D\u5185\u5B58\u7684\u5927\u5C0F +sql.DbMemAnalysis.title = \u6570\u636E\u5E93\u5185\u5B58\u5206\u6790 +sql.DbMemAnalysis.title.normal = \u6570\u636E\u5E93\u5185\u5B58\u5206\u6790 +sql.DbMemAnalysis.title.high = \u6570\u636E\u5E93\u5185\u5B58\u5206\u6790 +sql.DbMemAnalysis.detail = \u8BE5\u8BCA\u65AD\u9879\u65E8\u5728\u901A\u8FC7\u67E5\u8BE2\u5F53\u524D\u65F6\u523B\u5DF2\u4F7F\u7528\u7684\u6570\u636E\u5E93\u5185\u5B58\u5360\u6BD4\uFF0C\u68C0\u67E5\u662F\u5426\u8D85\u8FC7\u8BBE\u5B9A\u9608\u503C\uFF0C\u4ECE\u800C\u5224\u65AD\u6570\u636E\u5E93\u5185\u5B58\u662F\u5426\u8D85\u9650\u3002\u5F53\u6570\u636E\u5E93\u5185\u5B58\u4E0D\u8DB3\u65F6\uFF0C\u53EF\u80FD\u4F1A\u5F71\u54CD\u6027\u80FD\uFF0C\u4E25\u91CD\u60C5\u51B5\u4E0B\u751A\u81F3\u5BFC\u81F4\u6570\u636E\u5E93\u5D29\u6E83\u3002\n \u6570\u636E\u5E93\u5185\u5B58\u4F7F\u7528\u7387=\u6570\u636E\u5E93\u8FDB\u7A0B\u5F53\u524D\u4F7F\u7528\u7684\u5185\u5B58\u5927\u5C0F\uFF08process_used_memory\uFF09 / \u53C2\u6570\u8BBE\u7F6E\u7684\u6700\u5927\u5185\u5B58 \uFF08max_process_memory\uFF09* 100% +sql.DbMemAnalysis.suggest = \u6839\u636E{0}\u65F6\u95F4\u91C7\u96C6\u7684\u6570\u636E\u5206\u6790\uFF0C\u5F53\u524D\u6570\u636E\u5E93\u5185\u5B58\u4F7F\u7528\u7387{1}%\u5DF2\u8D85\u8FC7\u8BBE\u5B9A\u7684{2}%\u9608\u503C\uFF0C\u5185\u5B58\u8D44\u6E90\u5373\u5C06\u8017\u5C3D\u3002\u9700\u8981\u5BF9\u6570\u636E\u5E93\u7684\u5185\u5B58\u4F7F\u7528\u60C5\u51B5\u8FDB\u884C\u8BE6\u7EC6\u5206\u6790\uFF0C\u7279\u522B\u662F\u52A8\u6001\u5185\u5B58\u548C\u5171\u4EAB\u5185\u5B58\u7684\u4F7F\u7528\u60C5\u51B5\uFF0C\u4EE5\u4FBF\u91C7\u53D6\u76F8\u5E94\u7684\u4F18\u5316\u63AA\u65BD\u3002 +sql.DbMemAnalysis.suggest.normal = \u6839\u636E{0}\u65F6\u95F4\u91C7\u96C6\u7684\u6570\u636E\u5206\u6790\uFF0C\u5F53\u524D\u6570\u636E\u5E93\u5185\u5B58\u4F7F\u7528\u7387{1}%\u672A\u8D85\u8FC7\u8BBE\u5B9A\u7684{2}%\u9608\u503C\uFF0C\u6570\u636E\u5E93\u5185\u5B58\u4F7F\u7528\u6B63\u5E38\u3002 +sql.DbMemAnalysis.suggest.high = \u6839\u636E{0}\u65F6\u95F4\u91C7\u96C6\u7684\u6570\u636E\u5206\u6790\uFF0C\u5F53\u524D\u6570\u636E\u5E93\u5185\u5B58\u4F7F\u7528\u7387{1}%\u5DF2\u8D85\u8FC7\u8BBE\u5B9A\u7684{2}%\u9608\u503C\uFF0C\u5185\u5B58\u8D44\u6E90\u5373\u5C06\u8017\u5C3D\u3002\u9700\u8981\u5BF9\u6570\u636E\u5E93\u7684\u5185\u5B58\u4F7F\u7528\u60C5\u51B5\u8FDB\u884C\u8BE6\u7EC6\u5206\u6790\uFF0C\u7279\u522B\u662F\u52A8\u6001\u5185\u5B58\u548C\u5171\u4EAB\u5185\u5B58\u7684\u4F7F\u7528\u60C5\u51B5\uFF0C\u4EE5\u4FBF\u91C7\u53D6\u76F8\u5E94\u7684\u4F18\u5316\u63AA\u65BD\u3002 +ResultType.DbDynamicMemory = \u52A8\u6001\u5185\u5B58\u4F7F\u7528\u8FC7\u9AD8 +DbDynamicMemory.tip = \u6839\u636E{0}\u65F6\u95F4\u91C7\u96C6\u7684\u6570\u636E\u5206\u6790\uFF0C\u5F53\u524D\u52A8\u6001\u5185\u5B58\u4F7F\u7528\u7387{1}%\u5DF2\u8D85\u8FC7\u8BBE\u5B9A\u7684{2}%\u9608\u503C\uFF0C\u8868\u660E\u6570\u636E\u5E93\u5185\u5B58\u4E3B\u8981\u88AB\u52A8\u6001\u5185\u5B58\u5360\u7528\u3002\u9700\u8981\u5BF9\u52A8\u6001\u5185\u5B58\u4F7F\u7528\u60C5\u51B5\u8FDB\u884C\u8BE6\u7EC6\u5206\u6790\uFF0C\u68C0\u67E5\u662F\u5426\u5B58\u5728\u5F02\u5E38\u4F1A\u8BDD\u7684 SQL \u5360\u7528\u8FC7\u591A\u52A8\u6001\u5185\u5B58\uFF0C\u6216\u662F\u5426\u53D1\u751F\u4E86\u5185\u5B58\u6CC4\u6F0F\u5BFC\u81F4\u52A8\u6001\u5185\u5B58\u589E\u957F\u5F02\u5E38\u3002 +DbDynamicMemoryTable.name = \u6570\u636E\u5E93\u52A8\u6001\u5185\u5B58\u4F7F\u7528\u60C5\u51B5 +DbDynamicMemoryTable.column.totalsize = \u603B\u7684\u52A8\u6001\u5185\u5B58 +DbDynamicMemoryTable.column.freesize = \u5DF2\u91CA\u653E\u7684\u52A8\u6001\u5185\u5B58 +DbDynamicMemoryTable.column.usedsize = \u5DF2\u4F7F\u7528\u7684\u52A8\u6001\u5185\u5B58 +DbDynamicMemoryTable.column.process_used_memory = \u6570\u636E\u5E93\u8FDB\u7A0B\u5F53\u524D\u4F7F\u7528\u7684\u5185\u5B58 +sql.DbDynamicMemory.title = \u52A8\u6001\u5185\u5B58\u4F7F\u7528\u8FC7\u9AD8 +sql.DbDynamicMemory.title.normal = \u52A8\u6001\u5185\u5B58\u4F7F\u7528\u8FC7\u9AD8 +sql.DbDynamicMemory.title.high = \u52A8\u6001\u5185\u5B58\u4F7F\u7528\u8FC7\u9AD8 +sql.DbDynamicMemory.detail = \u8BE5\u8BCA\u65AD\u9879\u65E8\u5728\u901A\u8FC7\u67E5\u8BE2\u5F53\u524D\u65F6\u523B\u5DF2\u4F7F\u7528\u7684\u52A8\u6001\u5185\u5B58\u5360\u6BD4\uFF0C\u5224\u65AD\u662F\u5426\u8D85\u8FC7\u8BBE\u5B9A\u7684\u9608\u503C\uFF0C\u4ECE\u800C\u68C0\u67E5\u6570\u636E\u5E93\u5185\u5B58\u662F\u5426\u4E3B\u8981\u88AB\u52A8\u6001\u5185\u5B58\u5360\u7528\u3002\u5982\u679C\u52A8\u6001\u5185\u5B58\u5360\u7528\u8FC7\u9AD8\uFF0C\u53EF\u80FD\u4F1A\u5BFC\u81F4\u6570\u636E\u5E93\u6027\u80FD\u4E0B\u964D\uFF0C\u751A\u81F3\u5F71\u54CD\u7CFB\u7EDF\u7A33\u5B9A\u6027\u3002\u6B64\u9879\u5206\u6790\u6709\u52A9\u4E8E\u53CA\u65F6\u53D1\u73B0\u6F5C\u5728\u95EE\u9898\uFF0C\u8FDB\u4E00\u6B65\u6392\u67E5\u662F\u5426\u7531\u4E8E\u5F02\u5E38\u4F1A\u8BDD\u3001\u8FC7\u9AD8\u7684 SQL \u67E5\u8BE2\u6216\u5185\u5B58\u6CC4\u6F0F\u7B49\u539F\u56E0\u5BFC\u81F4\u52A8\u6001\u5185\u5B58\u4F7F\u7528\u5F02\u5E38\u3002\n \u52A8\u6001\u5185\u5B58\u4F7F\u7528\u7387=\u5DF2\u4F7F\u7528\u7684\u52A8\u6001\u5185\u5B58\u5927\u5C0F \uFF08usedsize\uFF09/ \u6570\u636E\u5E93\u8FDB\u7A0B\u5F53\u524D\u4F7F\u7528\u7684\u5185\u5B58\u5927\u5C0F\uFF08process_used_memory\uFF09 * 100% +sql.DbDynamicMemory.suggest = \u6839\u636E{0}\u65F6\u95F4\u91C7\u96C6\u7684\u6570\u636E\u5206\u6790\uFF0C\u5F53\u524D\u52A8\u6001\u5185\u5B58\u4F7F\u7528\u7387{1}%\u5DF2\u8D85\u8FC7\u8BBE\u5B9A\u7684{2}%\u9608\u503C\uFF0C\u8868\u660E\u6570\u636E\u5E93\u5185\u5B58\u4E3B\u8981\u88AB\u52A8\u6001\u5185\u5B58\u5360\u7528\u3002\u9700\u8981\u5BF9\u52A8\u6001\u5185\u5B58\u4F7F\u7528\u60C5\u51B5\u8FDB\u884C\u8BE6\u7EC6\u5206\u6790\uFF0C\u68C0\u67E5\u662F\u5426\u5B58\u5728\u5F02\u5E38\u4F1A\u8BDD\u7684 SQL \u5360\u7528\u8FC7\u591A\u52A8\u6001\u5185\u5B58\uFF0C\u6216\u662F\u5426\u53D1\u751F\u4E86\u5185\u5B58\u6CC4\u6F0F\u5BFC\u81F4\u52A8\u6001\u5185\u5B58\u589E\u957F\u5F02\u5E38\u3002 +sql.DbDynamicMemory.suggest.normal = \u6839\u636E{0}\u65F6\u95F4\u91C7\u96C6\u7684\u6570\u636E\u5206\u6790\uFF0C\u5F53\u524D\u52A8\u6001\u5185\u5B58\u4F7F\u7528\u7387{1}%\u672A\u8D85\u8FC7\u8BBE\u5B9A\u7684{2}%\u9608\u503C\uFF0C\u6570\u636E\u5E93\u52A8\u6001\u5185\u5B58\u4F7F\u7528\u6B63\u5E38\u3002 +sql.DbDynamicMemory.suggest.high = \u6839\u636E{0}\u65F6\u95F4\u91C7\u96C6\u7684\u6570\u636E\u5206\u6790\uFF0C\u5F53\u524D\u52A8\u6001\u5185\u5B58\u4F7F\u7528\u7387{1}%\u5DF2\u8D85\u8FC7\u8BBE\u5B9A\u7684{2}%\u9608\u503C\uFF0C\u8868\u660E\u6570\u636E\u5E93\u5185\u5B58\u4E3B\u8981\u88AB\u52A8\u6001\u5185\u5B58\u5360\u7528\u3002\u9700\u8981\u5BF9\u52A8\u6001\u5185\u5B58\u4F7F\u7528\u60C5\u51B5\u8FDB\u884C\u8BE6\u7EC6\u5206\u6790\uFF0C\u68C0\u67E5\u662F\u5426\u5B58\u5728\u5F02\u5E38\u4F1A\u8BDD\u7684 SQL \u5360\u7528\u8FC7\u591A\u52A8\u6001\u5185\u5B58\uFF0C\u6216\u662F\u5426\u53D1\u751F\u4E86\u5185\u5B58\u6CC4\u6F0F\u5BFC\u81F4\u52A8\u6001\u5185\u5B58\u589E\u957F\u5F02\u5E38\u3002 +ResultType.SqlUseDynamicMem = \u5F02\u5E38SQL\u5360\u7528\u52A8\u6001\u5185\u5B58\u8FC7\u9AD8 +SqlUseDynamicMem.tip = \u4E0B\u8868\u5C55\u793A\u4E86TOP 10 SQL \u67E5\u8BE2\u7684\u52A8\u6001\u5185\u5B58\u4F7F\u7528\u60C5\u51B5\u3002\u5EFA\u8BAE\u91CD\u70B9\u5206\u6790\u90A3\u4E9B\u5360\u7528\u52A8\u6001\u5185\u5B58\u8F83\u5927\u7684 SQL \u8BED\u53E5\uFF0C\u627E\u51FA\u6F5C\u5728\u7684\u6027\u80FD\u74F6\u9888\uFF0C\u4F18\u5316\u67E5\u8BE2\u6216\u8C03\u6574\u6267\u884C\u8BA1\u5212\uFF0C\u4EE5\u51CF\u5C11\u5185\u5B58\u6D88\u8017\u548C\u63D0\u9AD8\u7CFB\u7EDF\u6027\u80FD\u3002 +SqlUseDynamicMemTable.name = SQL\u4F7F\u7528\u52A8\u6001\u5185\u5B58\u4F7F\u7528\u60C5\u51B5 +SqlUseDynamicMemTable.column.totalsize = \u603B\u7684\u5171\u4EAB\u5185\u5B58 +SqlUseDynamicMemTable.column.freesize = \u5DF2\u91CA\u653E\u7684\u5171\u4EAB\u5185\u5B58 +SqlUseDynamicMemTable.column.usedsize = \u5DF2\u4F7F\u7528\u7684\u5171\u4EAB\u5185\u5B58 +SqlUseDynamicMemTable.column.query = SQL\u8BED\u53E5 +SqlUseDynamicMemTable.column.sessionid = \u4F1A\u8BDDID +sql.SqlUseDynamicMem.title = \u5F02\u5E38SQL\u5360\u7528\u52A8\u6001\u5185\u5B58\u8FC7\u9AD8 +sql.SqlUseDynamicMem.title.normal = \u5F02\u5E38SQL\u5360\u7528\u52A8\u6001\u5185\u5B58\u8FC7\u9AD8 +sql.SqlUseDynamicMem.title.high = \u5F02\u5E38SQL\u5360\u7528\u52A8\u6001\u5185\u5B58\u8FC7\u9AD8 +sql.SqlUseDynamicMem.detail = \u8BE5\u8BCA\u65AD\u9879\u901A\u8FC7\u67E5\u8BE2\u5F53\u524D\u4F1A\u8BDD\u7684\u52A8\u6001\u5185\u5B58\u4F7F\u7528\u60C5\u51B5\uFF0C\u5E76\u6839\u636E SQL \u8BED\u53E5\u8FDB\u884C\u5206\u7EC4\uFF0C\u6309\u5DF2\u4F7F\u7528\u7684\u5185\u5B58\u91CF\u964D\u5E8F\u6392\u5217\u3002\u5EFA\u8BAE\u4ECE\u5185\u5B58\u5360\u7528\u8F83\u9AD8\u7684 SQL \u67E5\u8BE2\u5165\u624B\uFF0C\u5206\u6790\u662F\u5426\u5B58\u5728\u6267\u884C\u6548\u7387\u4F4E\u4E0B\u6216\u8D44\u6E90\u6D88\u8017\u8FC7\u5927\u7684\u95EE\u9898\u3002\u91CD\u70B9\u6392\u67E5\u8FD9\u4E9B\u9AD8\u5185\u5B58\u5360\u7528\u7684 SQL \u8BED\u53E5\uFF0C\u627E\u51FA\u6F5C\u5728\u7684\u6027\u80FD\u74F6\u9888\u3002\u901A\u8FC7\u4F18\u5316\u67E5\u8BE2\u8BED\u53E5\u6216\u8C03\u6574\u76F8\u5173\u914D\u7F6E\uFF0C\u80FD\u591F\u6709\u6548\u51CF\u5C11\u5185\u5B58\u5360\u7528\uFF0C\u63D0\u9AD8\u67E5\u8BE2\u6548\u7387\uFF0C\u4ECE\u800C\u63D0\u5347\u7CFB\u7EDF\u7684\u6574\u4F53\u6027\u80FD\u548C\u7A33\u5B9A\u6027\u3002 +sql.SqlUseDynamicMem.suggest = \u4E0B\u8868\u5C55\u793A\u4E86TOP 10 SQL \u67E5\u8BE2\u7684\u52A8\u6001\u5185\u5B58\u4F7F\u7528\u60C5\u51B5\u3002\u5EFA\u8BAE\u91CD\u70B9\u5206\u6790\u90A3\u4E9B\u5360\u7528\u52A8\u6001\u5185\u5B58\u8F83\u5927\u7684 SQL \u8BED\u53E5\uFF0C\u627E\u51FA\u6F5C\u5728\u7684\u6027\u80FD\u74F6\u9888\uFF0C\u4F18\u5316\u67E5\u8BE2\u6216\u8C03\u6574\u6267\u884C\u8BA1\u5212\uFF0C\u4EE5\u51CF\u5C11\u5185\u5B58\u6D88\u8017\u548C\u63D0\u9AD8\u7CFB\u7EDF\u6027\u80FD\u3002 +sql.SqlUseDynamicMem.suggest.normal = \u4E0B\u8868\u5C55\u793A\u4E86TOP 10 SQL \u67E5\u8BE2\u7684\u52A8\u6001\u5185\u5B58\u4F7F\u7528\u60C5\u51B5\u3002\u5EFA\u8BAE\u91CD\u70B9\u5206\u6790\u90A3\u4E9B\u5360\u7528\u52A8\u6001\u5185\u5B58\u8F83\u5927\u7684 SQL \u8BED\u53E5\uFF0C\u627E\u51FA\u6F5C\u5728\u7684\u6027\u80FD\u74F6\u9888\uFF0C\u4F18\u5316\u67E5\u8BE2\u6216\u8C03\u6574\u6267\u884C\u8BA1\u5212\uFF0C\u4EE5\u51CF\u5C11\u5185\u5B58\u6D88\u8017\u548C\u63D0\u9AD8\u7CFB\u7EDF\u6027\u80FD\u3002 +sql.SqlUseDynamicMem.suggest.high = \u4E0B\u8868\u5C55\u793A\u4E86TOP 10 SQL \u67E5\u8BE2\u7684\u52A8\u6001\u5185\u5B58\u4F7F\u7528\u60C5\u51B5\u3002\u5EFA\u8BAE\u91CD\u70B9\u5206\u6790\u90A3\u4E9B\u5360\u7528\u52A8\u6001\u5185\u5B58\u8F83\u5927\u7684 SQL \u8BED\u53E5\uFF0C\u627E\u51FA\u6F5C\u5728\u7684\u6027\u80FD\u74F6\u9888\uFF0C\u4F18\u5316\u67E5\u8BE2\u6216\u8C03\u6574\u6267\u884C\u8BA1\u5212\uFF0C\u4EE5\u51CF\u5C11\u5185\u5B58\u6D88\u8017\u548C\u63D0\u9AD8\u7CFB\u7EDF\u6027\u80FD\u3002 +ResultType.DbMemLeak = \u52A8\u6001\u5185\u5B58\u5185\u5B58\u6CC4\u6F0F +DbMemLeak.tip = \u5F53\u524D\u663E\u793A\u7684\u662F TOP 10 \u8C03\u7528\u6808\u4E2D\u672A\u91CA\u653E\u5185\u5B58\u7684\u60C5\u51B5\u3002\u5EFA\u8BAE\u91CD\u70B9\u5206\u6790\u90A3\u4E9B\u672A\u91CA\u653E\u5185\u5B58\u8F83\u5927\u7684\u8C03\u7528\u6808\uFF0C\u4EE5\u4FBF\u53D1\u73B0\u6F5C\u5728\u7684\u5185\u5B58\u6CC4\u6F0F\u95EE\u9898\u3002\u901A\u8FC7\u6DF1\u5165\u68C0\u67E5\u8FD9\u4E9B\u8C03\u7528\u6808\u7684\u5185\u5B58\u5206\u914D\u4E0E\u91CA\u653E\u903B\u8F91\uFF0C\u53EF\u4EE5\u6709\u6548\u8BC6\u522B\u5E76\u4FEE\u590D\u53EF\u80FD\u7684\u5185\u5B58\u6CC4\u6F0F\uFF0C\u4ECE\u800C\u51CF\u5C11\u5185\u5B58\u6D88\u8017\uFF0C\u63D0\u5347\u7CFB\u7EDF\u6027\u80FD\u548C\u7A33\u5B9A\u6027\u3002 +DbMemLeakTable.name = \u672A\u91CA\u653E\u5185\u5B58\u7684\u8C03\u7528\u6808\u4FE1\u606F +DbMemLeakTable.column.timePoint = \u91C7\u6837\u65F6\u95F4 +DbMemLeakTable.column.stackInfo = \u8C03\u7528\u6808 +DbMemLeakTable.column.leakSize = \u672A\u91CA\u653E\u7684\u603B\u5185\u5B58\u5927\u5C0F +DbMemLeakTable.column.leakCount = \u7533\u8BF7\u5185\u5B58\u672A\u91CA\u653E\u7684\u6B21\u6570 +DbMemLeakChart.name = \u6570\u636E\u5E93\u5185\u5B58\u6CC4\u6F0F\u60C5\u51B5 +DbMemLeakChart.unit = \u5B57\u8282 +DbMemLeakChart.data = \u672A\u91CA\u653E\u7684\u603B\u5185\u5B58\u5927\u5C0F +sql.DbMemLeak.title = \u52A8\u6001\u5185\u5B58\u5185\u5B58\u6CC4\u6F0F +sql.DbMemLeak.title.normal = \u52A8\u6001\u5185\u5B58\u5185\u5B58\u6CC4\u6F0F +sql.DbMemLeak.title.high = \u52A8\u6001\u5185\u5B58\u5185\u5B58\u6CC4\u6F0F +sql.DbMemLeak.detail = \u8BE5\u8BCA\u65AD\u9879\u65E8\u5728\u68C0\u6D4B\u5185\u5B58\u6CC4\u6F0F\u95EE\u9898\uFF0C\u9632\u6B62\u5176\u5BFC\u81F4\u52A8\u6001\u5185\u5B58\u5360\u7528\u8FC7\u9AD8\u3002\u901A\u8FC7 eBPF \u6280\u672F\uFF0C\u5206\u6790 SQL \u8BCA\u65AD\u671F\u95F4\u6570\u636E\u5E93\u5185\u6838\u8C03\u7528\u6808\u4E2D\u7684\u5185\u5B58\u7533\u8BF7\u4E0E\u91CA\u653E\u60C5\u51B5\uFF0C\u80FD\u591F\u8BC6\u522B\u662F\u5426\u5B58\u5728\u672A\u91CA\u653E\u7684\u5185\u5B58\u8D44\u6E90\u3002\u5BF9\u4E8E\u53EF\u80FD\u5F15\u53D1\u5185\u5B58\u6CC4\u6F0F\u7684\u8C03\u7528\u6808\uFF0C\u5EFA\u8BAE\u6DF1\u5165\u5206\u6790\u5176\u5185\u5B58\u5206\u914D\u4E0E\u91CA\u653E\u8FC7\u7A0B\uFF0C\u5E76\u91C7\u53D6\u76F8\u5E94\u4F18\u5316\u63AA\u65BD\uFF0C\u4EE5\u51CF\u5C11\u5185\u5B58\u5360\u7528\u5E76\u63D0\u5347\u7CFB\u7EDF\u7684\u6574\u4F53\u6027\u80FD\u4E0E\u7A33\u5B9A\u6027\u3002 +sql.DbMemLeak.suggest = \u5F53\u524D\u663E\u793A\u7684\u662F TOP 10 \u8C03\u7528\u6808\u4E2D\u672A\u91CA\u653E\u5185\u5B58\u7684\u60C5\u51B5\u3002\u5EFA\u8BAE\u91CD\u70B9\u5206\u6790\u90A3\u4E9B\u672A\u91CA\u653E\u5185\u5B58\u8F83\u5927\u7684\u8C03\u7528\u6808\uFF0C\u4EE5\u4FBF\u53D1\u73B0\u6F5C\u5728\u7684\u5185\u5B58\u6CC4\u6F0F\u95EE\u9898\u3002\u901A\u8FC7\u6DF1\u5165\u68C0\u67E5\u8FD9\u4E9B\u8C03\u7528\u6808\u7684\u5185\u5B58\u5206\u914D\u4E0E\u91CA\u653E\u903B\u8F91\uFF0C\u53EF\u4EE5\u6709\u6548\u8BC6\u522B\u5E76\u4FEE\u590D\u53EF\u80FD\u7684\u5185\u5B58\u6CC4\u6F0F\uFF0C\u4ECE\u800C\u51CF\u5C11\u5185\u5B58\u6D88\u8017\uFF0C\u63D0\u5347\u7CFB\u7EDF\u6027\u80FD\u548C\u7A33\u5B9A\u6027\u3002 +sql.DbMemLeak.suggest.normal = \u5F53\u524D\u663E\u793A\u7684\u662F TOP 10 \u8C03\u7528\u6808\u4E2D\u672A\u91CA\u653E\u5185\u5B58\u7684\u60C5\u51B5\u3002\u5EFA\u8BAE\u91CD\u70B9\u5206\u6790\u90A3\u4E9B\u672A\u91CA\u653E\u5185\u5B58\u8F83\u5927\u7684\u8C03\u7528\u6808\uFF0C\u4EE5\u4FBF\u53D1\u73B0\u6F5C\u5728\u7684\u5185\u5B58\u6CC4\u6F0F\u95EE\u9898\u3002\u901A\u8FC7\u6DF1\u5165\u68C0\u67E5\u8FD9\u4E9B\u8C03\u7528\u6808\u7684\u5185\u5B58\u5206\u914D\u4E0E\u91CA\u653E\u903B\u8F91\uFF0C\u53EF\u4EE5\u6709\u6548\u8BC6\u522B\u5E76\u4FEE\u590D\u53EF\u80FD\u7684\u5185\u5B58\u6CC4\u6F0F\uFF0C\u4ECE\u800C\u51CF\u5C11\u5185\u5B58\u6D88\u8017\uFF0C\u63D0\u5347\u7CFB\u7EDF\u6027\u80FD\u548C\u7A33\u5B9A\u6027\u3002 +sql.DbMemLeak.suggest.high = \u5F53\u524D\u663E\u793A\u7684\u662F TOP 10 \u8C03\u7528\u6808\u4E2D\u672A\u91CA\u653E\u5185\u5B58\u7684\u60C5\u51B5\u3002\u5EFA\u8BAE\u91CD\u70B9\u5206\u6790\u90A3\u4E9B\u672A\u91CA\u653E\u5185\u5B58\u8F83\u5927\u7684\u8C03\u7528\u6808\uFF0C\u4EE5\u4FBF\u53D1\u73B0\u6F5C\u5728\u7684\u5185\u5B58\u6CC4\u6F0F\u95EE\u9898\u3002\u901A\u8FC7\u6DF1\u5165\u68C0\u67E5\u8FD9\u4E9B\u8C03\u7528\u6808\u7684\u5185\u5B58\u5206\u914D\u4E0E\u91CA\u653E\u903B\u8F91\uFF0C\u53EF\u4EE5\u6709\u6548\u8BC6\u522B\u5E76\u4FEE\u590D\u53EF\u80FD\u7684\u5185\u5B58\u6CC4\u6F0F\uFF0C\u4ECE\u800C\u51CF\u5C11\u5185\u5B58\u6D88\u8017\uFF0C\u63D0\u5347\u7CFB\u7EDF\u6027\u80FD\u548C\u7A33\u5B9A\u6027\u3002 +ResultType.DbShareMemory = \u5171\u4EAB\u5185\u5B58\u4F7F\u7528\u8FC7\u9AD8 +DbShareMemory.tip = \u6839\u636E{0}\u65F6\u95F4\u91C7\u96C6\u7684\u6570\u636E\u5206\u6790\uFF0C\u5F53\u524D\u5171\u4EAB\u5185\u5B58\u4F7F\u7528\u7387{1}%\u5DF2\u8D85\u8FC7\u8BBE\u5B9A\u7684{2}%\u9608\u503C\uFF0C\u8868\u660E\u6570\u636E\u5E93\u5185\u5B58\u4E3B\u8981\u88AB\u5171\u4EAB\u5185\u5B58\u5360\u7528\u3002\u9700\u8981\u5BF9\u5171\u4EAB\u5185\u5B58\u4F7F\u7528\u60C5\u51B5\u8FDB\u884C\u8BE6\u7EC6\u5206\u6790\uFF0C\u68C0\u67E5\u662F\u5426\u5B58\u5728\u5F02\u5E38\u4E0A\u4E0B\u6587\u4F7F\u7528\u5171\u4EAB\u5185\u5B58\u8FC7\u591A\u5BFC\u81F4\u5171\u4EAB\u5185\u5B58\u589E\u957F\u5F02\u5E38\u3002 +DbShareMemoryTable.name = \u6570\u636E\u5E93\u5171\u4EAB\u5185\u5B58\u4F7F\u7528\u60C5\u51B5 +DbShareMemoryTable.column.totalsize = \u603B\u7684\u5171\u4EAB\u5185\u5B58 +DbShareMemoryTable.column.freesize = \u5DF2\u91CA\u653E\u7684\u5171\u4EAB\u5185\u5B58 +DbShareMemoryTable.column.usedsize = \u5DF2\u4F7F\u7528\u7684\u5171\u4EAB\u5185\u5B58 +DbShareMemoryTable.column.process_used_memory = \u6570\u636E\u5E93\u8FDB\u7A0B\u5F53\u524D\u4F7F\u7528\u7684\u5185\u5B58 +sql.DbShareMemory.title = \u5171\u4EAB\u5185\u5B58\u4F7F\u7528\u8FC7\u9AD8 +sql.DbShareMemory.title.normal = \u5171\u4EAB\u5185\u5B58\u4F7F\u7528\u8FC7\u9AD8 +sql.DbShareMemory.title.high = \u5171\u4EAB\u5185\u5B58\u4F7F\u7528\u8FC7\u9AD8 +sql.DbShareMemory.detail = \u8BE5\u8BCA\u65AD\u9879\u65E8\u5728\u901A\u8FC7\u67E5\u8BE2\u5F53\u524D\u65F6\u523B\u5DF2\u4F7F\u7528\u7684\u5171\u4EAB\u5185\u5B58\u5360\u6BD4\uFF0C\u5224\u65AD\u662F\u5426\u8D85\u8FC7\u8BBE\u5B9A\u7684\u9608\u503C\uFF0C\u4ECE\u800C\u68C0\u67E5\u6570\u636E\u5E93\u5185\u5B58\u662F\u5426\u4E3B\u8981\u88AB\u5171\u4EAB\u5185\u5B58\u5360\u7528\u3002\u5982\u679C\u5171\u4EAB\u5185\u5B58\u5360\u7528\u8FC7\u9AD8\uFF0C\u53EF\u80FD\u4F1A\u5BFC\u81F4\u6570\u636E\u5E93\u6027\u80FD\u4E0B\u964D\uFF0C\u751A\u81F3\u5F71\u54CD\u7CFB\u7EDF\u7A33\u5B9A\u6027\u3002\u6B64\u9879\u5206\u6790\u6709\u52A9\u4E8E\u53CA\u65F6\u53D1\u73B0\u6F5C\u5728\u95EE\u9898\uFF0C\u8FDB\u4E00\u6B65\u6392\u67E5\u662F\u5426\u7531\u4E8E\u5F02\u5E38\u4E0A\u4E0B\u6587\u6216\u5185\u5B58\u6CC4\u6F0F\u7B49\u539F\u56E0\u5BFC\u81F4\u5171\u4EAB\u5185\u5B58\u4F7F\u7528\u5F02\u5E38\u3002\n \u5171\u4EAB\u5185\u5B58\u4F7F\u7528\u7387=\u5DF2\u4F7F\u7528\u7684\u5171\u4EAB\u5185\u5B58\u5927\u5C0F \uFF08usedsize\uFF09/ \u6570\u636E\u5E93\u8FDB\u7A0B\u5F53\u524D\u4F7F\u7528\u7684\u5185\u5B58\u5927\u5C0F\uFF08process_used_memory\uFF09 * 100% +sql.DbShareMemory.suggest = \u6839\u636E{0}\u65F6\u95F4\u91C7\u96C6\u7684\u6570\u636E\u5206\u6790\uFF0C\u5F53\u524D\u5171\u4EAB\u5185\u5B58\u4F7F\u7528\u7387{1}%\u5DF2\u8D85\u8FC7\u8BBE\u5B9A\u7684{2}%\u9608\u503C\uFF0C\u8868\u660E\u6570\u636E\u5E93\u5185\u5B58\u4E3B\u8981\u88AB\u5171\u4EAB\u5185\u5B58\u5360\u7528\u3002\u9700\u8981\u5BF9\u5171\u4EAB\u5185\u5B58\u4F7F\u7528\u60C5\u51B5\u8FDB\u884C\u8BE6\u7EC6\u5206\u6790\uFF0C\u68C0\u67E5\u662F\u5426\u5B58\u5728\u5F02\u5E38\u4E0A\u4E0B\u6587\u4F7F\u7528\u5171\u4EAB\u5185\u5B58\u8FC7\u591A\u5BFC\u81F4\u5171\u4EAB\u5185\u5B58\u589E\u957F\u5F02\u5E38\u3002 +sql.DbShareMemory.suggest.normal = \u6839\u636E{0}\u65F6\u95F4\u91C7\u96C6\u7684\u6570\u636E\u5206\u6790\uFF0C\u5F53\u524D\u5171\u4EAB\u5185\u5B58\u4F7F\u7528\u7387{1}%\u672A\u8D85\u8FC7\u8BBE\u5B9A\u7684{2}%\u9608\u503C\uFF0C\u6570\u636E\u5E93\u5171\u4EAB\u5185\u5B58\u4F7F\u7528\u6B63\u5E38\u3002 +sql.DbShareMemory.suggest.high = \u6839\u636E{0}\u65F6\u95F4\u91C7\u96C6\u7684\u6570\u636E\u5206\u6790\uFF0C\u5F53\u524D\u5171\u4EAB\u5185\u5B58\u4F7F\u7528\u7387{1}%\u5DF2\u8D85\u8FC7\u8BBE\u5B9A\u7684{2}%\u9608\u503C\uFF0C\u8868\u660E\u6570\u636E\u5E93\u5185\u5B58\u4E3B\u8981\u88AB\u5171\u4EAB\u5185\u5B58\u5360\u7528\u3002\u9700\u8981\u5BF9\u5171\u4EAB\u5185\u5B58\u4F7F\u7528\u60C5\u51B5\u8FDB\u884C\u8BE6\u7EC6\u5206\u6790\uFF0C\u68C0\u67E5\u662F\u5426\u5B58\u5728\u5F02\u5E38\u4E0A\u4E0B\u6587\u4F7F\u7528\u5171\u4EAB\u5185\u5B58\u8FC7\u591A\u5BFC\u81F4\u5171\u4EAB\u5185\u5B58\u589E\u957F\u5F02\u5E38\u3002 +ResultType.ContextUseShareMem = \u4E0A\u4E0B\u6587\u4F7F\u7528\u5171\u4EAB\u5185\u5B58\u8FC7\u9AD8 +ContextUseShareMem.tip = \u5F53\u524D\u663E\u793A\u7684\u662F TOP 10 \u4E0A\u4E0B\u6587\u4F7F\u7528\u5171\u4EAB\u5185\u5B58\u7684\u60C5\u51B5\u3002\u5EFA\u8BAE\u91CD\u70B9\u5206\u6790\u90A3\u4E9B\u5360\u7528\u5171\u4EAB\u5185\u5B58\u8F83\u5927\u7684\u4E0A\u4E0B\u6587\uFF0C\u4EE5\u8BC6\u522B\u6F5C\u5728\u7684\u8D44\u6E90\u5360\u7528\u5F02\u5E38\u3002\u901A\u8FC7\u6DF1\u5165\u5206\u6790\u8FD9\u4E9B\u4E0A\u4E0B\u6587\u7684\u5171\u4EAB\u5185\u5B58\u4F7F\u7528\u6A21\u5F0F\uFF0C\u53EF\u4EE5\u53D1\u73B0\u662F\u5426\u5B58\u5728\u4E0D\u5408\u7406\u7684\u5185\u5B58\u5206\u914D\u6216\u8D44\u6E90\u7ADE\u4E89\uFF0C\u4ECE\u800C\u4F18\u5316\u5185\u5B58\u4F7F\u7528\u6548\u7387\u3002\u8FDB\u4E00\u6B65\u7684\u4F18\u5316\u63AA\u65BD\u53EF\u5E2E\u52A9\u51CF\u8F7B\u5171\u4EAB\u5185\u5B58\u8D1F\u62C5\uFF0C\u63D0\u5347\u7CFB\u7EDF\u7684\u6027\u80FD\u548C\u54CD\u5E94\u901F\u5EA6\u3002 +ContextUseShareMemTable.name = \u4E0A\u4E0B\u6587\u4F7F\u7528\u5171\u4EAB\u5185\u5B58\u4F7F\u7528\u60C5\u51B5 +ContextUseShareMemTable.column.totalsize = \u603B\u7684\u5171\u4EAB\u5185\u5B58 +ContextUseShareMemTable.column.freesize = \u5DF2\u91CA\u653E\u7684\u5171\u4EAB\u5185\u5B58 +ContextUseShareMemTable.column.usedsize = \u5DF2\u4F7F\u7528\u7684\u5171\u4EAB\u5185\u5B58 +ContextUseShareMemTable.column.contextname = \u4E0A\u4E0B\u6587\u540D\u79F0 +ContextUseShareMemTable.column.count = \u6B21\u6570 +sql.ContextUseShareMem.title = \u4E0A\u4E0B\u6587\u4F7F\u7528\u5171\u4EAB\u5185\u5B58\u8FC7\u9AD8 +sql.ContextUseShareMem.title.normal = \u4E0A\u4E0B\u6587\u4F7F\u7528\u5171\u4EAB\u5185\u5B58\u8FC7\u9AD8 +sql.ContextUseShareMem.title.high = \u4E0A\u4E0B\u6587\u4F7F\u7528\u5171\u4EAB\u5185\u5B58\u8FC7\u9AD8 +sql.ContextUseShareMem.detail = \u8BE5\u8BCA\u65AD\u9879\u901A\u8FC7\u67E5\u8BE2\u4E0A\u4E0B\u6587\u7684\u5171\u4EAB\u5185\u5B58\u4F7F\u7528\u60C5\u51B5\uFF0C\u5E76\u6839\u636E\u4E0A\u4E0B\u6587\u8FDB\u884C\u5206\u7EC4\uFF0C\u6309\u5DF2\u4F7F\u7528\u7684\u5171\u4EAB\u5185\u5B58\u91CF\u964D\u5E8F\u6392\u5217\uFF0C\u4ECE\u800C\u8BC6\u522B\u51FA\u5F02\u5E38\u7684\u5171\u4EAB\u5185\u5B58\u4F7F\u7528\u60C5\u51B5\u3002\u5206\u6790\u8FD9\u4E9B\u5F02\u5E38\u60C5\u51B5\uFF0C\u53EF\u80FD\u662F\u7531\u4E8E\u4E0A\u4E0B\u6587\u5207\u6362\u3001\u8FDB\u7A0B\u95F4\u901A\u4FE1\u6216\u8D44\u6E90\u7ADE\u4E89\u7B49\u56E0\u7D20\u5BFC\u81F4\u7684\u5171\u4EAB\u5185\u5B58\u5F02\u5E38\u589E\u957F\u3002\u5EFA\u8BAE\u4F18\u5148\u68C0\u67E5\u8FD9\u4E9B\u5F02\u5E38\u4E0A\u4E0B\u6587\uFF0C\u5E76\u6839\u636E\u5206\u6790\u7ED3\u679C\u4F18\u5316\u7CFB\u7EDF\u914D\u7F6E\u6216\u8C03\u6574\u8D44\u6E90\u5206\u914D\uFF0C\u4EE5\u786E\u4FDD\u5171\u4EAB\u5185\u5B58\u5F97\u5230\u5408\u7406\u5229\u7528\uFF0C\u8FDB\u800C\u63D0\u5347\u7CFB\u7EDF\u7684\u6027\u80FD\u3001\u7A33\u5B9A\u6027\u548C\u8D44\u6E90\u5229\u7528\u6548\u7387\u3002 +sql.ContextUseShareMem.suggest = \u5F53\u524D\u663E\u793A\u7684\u662F TOP 10 \u4E0A\u4E0B\u6587\u4F7F\u7528\u5171\u4EAB\u5185\u5B58\u7684\u60C5\u51B5\u3002\u5EFA\u8BAE\u91CD\u70B9\u5206\u6790\u90A3\u4E9B\u5360\u7528\u5171\u4EAB\u5185\u5B58\u8F83\u5927\u7684\u4E0A\u4E0B\u6587\uFF0C\u4EE5\u8BC6\u522B\u6F5C\u5728\u7684\u8D44\u6E90\u5360\u7528\u5F02\u5E38\u3002\u901A\u8FC7\u6DF1\u5165\u5206\u6790\u8FD9\u4E9B\u4E0A\u4E0B\u6587\u7684\u5171\u4EAB\u5185\u5B58\u4F7F\u7528\u6A21\u5F0F\uFF0C\u53EF\u4EE5\u53D1\u73B0\u662F\u5426\u5B58\u5728\u4E0D\u5408\u7406\u7684\u5185\u5B58\u5206\u914D\u6216\u8D44\u6E90\u7ADE\u4E89\uFF0C\u4ECE\u800C\u4F18\u5316\u5185\u5B58\u4F7F\u7528\u6548\u7387\u3002\u8FDB\u4E00\u6B65\u7684\u4F18\u5316\u63AA\u65BD\u53EF\u5E2E\u52A9\u51CF\u8F7B\u5171\u4EAB\u5185\u5B58\u8D1F\u62C5\uFF0C\u63D0\u5347\u7CFB\u7EDF\u7684\u6027\u80FD\u548C\u54CD\u5E94\u901F\u5EA6\u3002 +sql.ContextUseShareMem.suggest.normal = \u5F53\u524D\u663E\u793A\u7684\u662F TOP 10 \u4E0A\u4E0B\u6587\u4F7F\u7528\u5171\u4EAB\u5185\u5B58\u7684\u60C5\u51B5\u3002\u5EFA\u8BAE\u91CD\u70B9\u5206\u6790\u90A3\u4E9B\u5360\u7528\u5171\u4EAB\u5185\u5B58\u8F83\u5927\u7684\u4E0A\u4E0B\u6587\uFF0C\u4EE5\u8BC6\u522B\u6F5C\u5728\u7684\u8D44\u6E90\u5360\u7528\u5F02\u5E38\u3002\u901A\u8FC7\u6DF1\u5165\u5206\u6790\u8FD9\u4E9B\u4E0A\u4E0B\u6587\u7684\u5171\u4EAB\u5185\u5B58\u4F7F\u7528\u6A21\u5F0F\uFF0C\u53EF\u4EE5\u53D1\u73B0\u662F\u5426\u5B58\u5728\u4E0D\u5408\u7406\u7684\u5185\u5B58\u5206\u914D\u6216\u8D44\u6E90\u7ADE\u4E89\uFF0C\u4ECE\u800C\u4F18\u5316\u5185\u5B58\u4F7F\u7528\u6548\u7387\u3002\u8FDB\u4E00\u6B65\u7684\u4F18\u5316\u63AA\u65BD\u53EF\u5E2E\u52A9\u51CF\u8F7B\u5171\u4EAB\u5185\u5B58\u8D1F\u62C5\uFF0C\u63D0\u5347\u7CFB\u7EDF\u7684\u6027\u80FD\u548C\u54CD\u5E94\u901F\u5EA6\u3002 +sql.ContextUseShareMem.suggest.high = \u5F53\u524D\u663E\u793A\u7684\u662F TOP 10 \u4E0A\u4E0B\u6587\u4F7F\u7528\u5171\u4EAB\u5185\u5B58\u7684\u60C5\u51B5\u3002\u5EFA\u8BAE\u91CD\u70B9\u5206\u6790\u90A3\u4E9B\u5360\u7528\u5171\u4EAB\u5185\u5B58\u8F83\u5927\u7684\u4E0A\u4E0B\u6587\uFF0C\u4EE5\u8BC6\u522B\u6F5C\u5728\u7684\u8D44\u6E90\u5360\u7528\u5F02\u5E38\u3002\u901A\u8FC7\u6DF1\u5165\u5206\u6790\u8FD9\u4E9B\u4E0A\u4E0B\u6587\u7684\u5171\u4EAB\u5185\u5B58\u4F7F\u7528\u6A21\u5F0F\uFF0C\u53EF\u4EE5\u53D1\u73B0\u662F\u5426\u5B58\u5728\u4E0D\u5408\u7406\u7684\u5185\u5B58\u5206\u914D\u6216\u8D44\u6E90\u7ADE\u4E89\uFF0C\u4ECE\u800C\u4F18\u5316\u5185\u5B58\u4F7F\u7528\u6548\u7387\u3002\u8FDB\u4E00\u6B65\u7684\u4F18\u5316\u63AA\u65BD\u53EF\u5E2E\u52A9\u51CF\u8F7B\u5171\u4EAB\u5185\u5B58\u8D1F\u62C5\uFF0C\u63D0\u5347\u7CFB\u7EDF\u7684\u6027\u80FD\u548C\u54CD\u5E94\u901F\u5EA6\u3002 +ResultType.MemoryAccumulation = \u5171\u4EAB\u5185\u5B58\u5185\u5B58\u5806\u79EF +MemoryAccumulation.tip = \u5F53\u524D\u663E\u793A\u7684\u662F\u4F7F\u7528\u5171\u4EAB\u5185\u5B58\u7684\u524D 10 \u4E2A\u4E0A\u4E0B\u6587\u7684\u5185\u5B58\u7533\u8BF7\u7684\u8BE6\u7EC6\u4FE1\u606F\u3002\u5EFA\u8BAE\u91CD\u70B9\u5206\u6790\u90A3\u4E9B\u5185\u5B58\u7533\u8BF7\u8F83\u5927\u7684\u4E0A\u4E0B\u6587\uFF0C\u4EE5\u8BC6\u522B\u662F\u5426\u5B58\u5728\u5185\u5B58\u6CC4\u6F0F\u6216\u672A\u91CA\u653E\u7684\u60C5\u51B5\u3002\u901A\u8FC7\u6DF1\u5165\u5206\u6790\u4EE3\u7801\uFF0C\u53EF\u4EE5\u67E5\u660E\u5185\u5B58\u5806\u79EF\u7684\u6839\u672C\u539F\u56E0\uFF0C\u4ECE\u800C\u4F18\u5316\u4EE3\u7801\uFF0C\u63D0\u5347\u7CFB\u7EDF\u7684\u6574\u4F53\u6027\u80FD\u3002 +MemoryAccumulationTable.name = \u4E0A\u4E0B\u6587\u7533\u8BF7\u5185\u5B58\u7684\u8BE6\u7EC6\u4FE1\u606F +MemoryAccumulationTable.column.contextname = \u4E0A\u4E0B\u6587\u540D\u79F0 +MemoryAccumulationTable.column.file = \u7533\u8BF7\u5185\u5B58\u6240\u5728\u6587\u4EF6\u7684\u6587\u4EF6\u540D +MemoryAccumulationTable.column.line = \u7533\u8BF7\u5185\u5B58\u6240\u5728\u6587\u4EF6\u7684\u4EE3\u7801\u884C\u53F7 +MemoryAccumulationTable.column.size = \u7533\u8BF7\u7684\u5185\u5B58\u5927\u5C0F +sql.MemoryAccumulation.title = \u4E0A\u4E0B\u6587\u7533\u8BF7\u5185\u5B58\u7684\u8BE6\u7EC6\u4FE1\u606F +sql.MemoryAccumulation.title.normal = \u4E0A\u4E0B\u6587\u7533\u8BF7\u5185\u5B58\u7684\u8BE6\u7EC6\u4FE1\u606F +sql.MemoryAccumulation.title.high = \u4E0A\u4E0B\u6587\u7533\u8BF7\u5185\u5B58\u7684\u8BE6\u7EC6\u4FE1\u606F +sql.MemoryAccumulation.detail = \u8BE5\u8BCA\u65AD\u9879\u901A\u8FC7\u67E5\u8BE2\u4E0A\u4E0B\u6587\u4F7F\u7528\u5171\u4EAB\u5185\u5B58\u7684\u8BE6\u7EC6\u4FE1\u606F\uFF0C\u6DB5\u76D6\u6BCF\u4E00\u5904\u5185\u5B58\u7533\u8BF7\u7684\u6587\u4EF6\u3001\u884C\u53F7\u53CA\u5176\u5927\u5C0F\uFF08\u5BF9\u4E8E\u540C\u4E00\u6587\u4EF6\u548C\u884C\u53F7\u7684\u5185\u5B58\u7533\u8BF7\uFF0C\u5927\u5C0F\u4F1A\u8FDB\u884C\u7D2F\u52A0\uFF09\u3002\u901A\u8FC7\u5206\u6790\u8FD9\u4E9B\u8BE6\u7EC6\u4FE1\u606F\uFF0C\u53EF\u4EE5\u6709\u6548\u8BC6\u522B\u4EE3\u7801\u4E2D\u662F\u5426\u5B58\u5728\u672A\u91CA\u653E\u5185\u5B58\u5BFC\u81F4\u7684\u5185\u5B58\u5806\u79EF\u95EE\u9898\uFF0C\u4ECE\u800C\u5E2E\u52A9\u5F00\u53D1\u4EBA\u5458\u53D1\u73B0\u6F5C\u5728\u7684\u5185\u5B58\u6CC4\u6F0F\u98CE\u9669\uFF0C\u4F18\u5316\u5185\u5B58\u7BA1\u7406\uFF0C\u63D0\u5347\u7CFB\u7EDF\u7A33\u5B9A\u6027\u548C\u6027\u80FD\u3002\n \u6CE8\uFF1A\u8BE5\u8BCA\u65AD\u9879\u4ECEopenGauss\u89C6\u56FE\u4E2D\u83B7\u53D6\u7684\u6570\u636E\uFF0C\u4E0D\u652F\u6301release\u7248\u672C\u5C0F\u578B\u5316\u573A\u666F\u3002\u4E14\u5FC5\u987B\u5177\u6709sysadmin\u6743\u9650\u6216\u8005monitor admin\u6743\u9650\u3002 +sql.MemoryAccumulation.suggest = \u5F53\u524D\u663E\u793A\u7684\u662F\u4F7F\u7528\u5171\u4EAB\u5185\u5B58\u7684\u524D 10 \u4E2A\u4E0A\u4E0B\u6587\u7684\u5185\u5B58\u7533\u8BF7\u7684\u8BE6\u7EC6\u4FE1\u606F\u3002\u5EFA\u8BAE\u91CD\u70B9\u5206\u6790\u90A3\u4E9B\u5185\u5B58\u7533\u8BF7\u8F83\u5927\u7684\u4E0A\u4E0B\u6587\uFF0C\u4EE5\u8BC6\u522B\u662F\u5426\u5B58\u5728\u5185\u5B58\u6CC4\u6F0F\u6216\u672A\u91CA\u653E\u7684\u60C5\u51B5\u3002\u901A\u8FC7\u6DF1\u5165\u5206\u6790\u4EE3\u7801\uFF0C\u53EF\u4EE5\u67E5\u660E\u5185\u5B58\u5806\u79EF\u7684\u6839\u672C\u539F\u56E0\uFF0C\u4ECE\u800C\u4F18\u5316\u4EE3\u7801\uFF0C\u63D0\u5347\u7CFB\u7EDF\u7684\u6574\u4F53\u6027\u80FD\u3002 +sql.MemoryAccumulation.suggest.normal = \u5F53\u524D\u663E\u793A\u7684\u662F\u4F7F\u7528\u5171\u4EAB\u5185\u5B58\u7684\u524D 10 \u4E2A\u4E0A\u4E0B\u6587\u7684\u5185\u5B58\u7533\u8BF7\u7684\u8BE6\u7EC6\u4FE1\u606F\u3002\u5EFA\u8BAE\u91CD\u70B9\u5206\u6790\u90A3\u4E9B\u5185\u5B58\u7533\u8BF7\u8F83\u5927\u7684\u4E0A\u4E0B\u6587\uFF0C\u4EE5\u8BC6\u522B\u662F\u5426\u5B58\u5728\u5185\u5B58\u6CC4\u6F0F\u6216\u672A\u91CA\u653E\u7684\u60C5\u51B5\u3002\u901A\u8FC7\u6DF1\u5165\u5206\u6790\u4EE3\u7801\uFF0C\u53EF\u4EE5\u67E5\u660E\u5185\u5B58\u5806\u79EF\u7684\u6839\u672C\u539F\u56E0\uFF0C\u4ECE\u800C\u4F18\u5316\u4EE3\u7801\uFF0C\u63D0\u5347\u7CFB\u7EDF\u7684\u6574\u4F53\u6027\u80FD\u3002 +sql.MemoryAccumulation.suggest.high = \u5F53\u524D\u663E\u793A\u7684\u662F\u4F7F\u7528\u5171\u4EAB\u5185\u5B58\u7684\u524D 10 \u4E2A\u4E0A\u4E0B\u6587\u7684\u5185\u5B58\u7533\u8BF7\u7684\u8BE6\u7EC6\u4FE1\u606F\u3002\u5EFA\u8BAE\u91CD\u70B9\u5206\u6790\u90A3\u4E9B\u5185\u5B58\u7533\u8BF7\u8F83\u5927\u7684\u4E0A\u4E0B\u6587\uFF0C\u4EE5\u8BC6\u522B\u662F\u5426\u5B58\u5728\u5185\u5B58\u6CC4\u6F0F\u6216\u672A\u91CA\u653E\u7684\u60C5\u51B5\u3002\u901A\u8FC7\u6DF1\u5165\u5206\u6790\u4EE3\u7801\uFF0C\u53EF\u4EE5\u67E5\u660E\u5185\u5B58\u5806\u79EF\u7684\u6839\u672C\u539F\u56E0\uFF0C\u4ECE\u800C\u4F18\u5316\u4EE3\u7801\uFF0C\u63D0\u5347\u7CFB\u7EDF\u7684\u6574\u4F53\u6027\u80FD\u3002 + history.AspAnalysis.title=\u6570\u636E\u5E93\u8FDB\u7A0BCPU\u5E73\u5747\u4F7F\u7528\u7387 history.AspAnalysis.title.normal=\u6570\u636E\u5E93\u8FDB\u7A0BCPU\u6CA1\u51FA\u73B0\u79D2\u7EA7\u6296\u52A8 diff --git a/plugins/observability-sql-diagnosis/src/main/resources/messages_en_US.properties b/plugins/observability-sql-diagnosis/src/main/resources/messages_en_US.properties index 2f2275d66..0a6d747bf 100644 --- a/plugins/observability-sql-diagnosis/src/main/resources/messages_en_US.properties +++ b/plugins/observability-sql-diagnosis/src/main/resources/messages_en_US.properties @@ -127,7 +127,7 @@ ResultType.MaxIoCapacity=Set the maximum IO limit per second for batch page brus ResultType.LogMinDurationStatement=Controls the duration of each completion statement recorded ResultType.LogDuration=Control the execution time of each completed SQL statement recorded ResultType.TrackStmtStatLevel=Level of control statement execution trace -ResultType.TrackStmtRetention Time=Controls the retention time of full/slow SQL records +ResultType.TrackStmtRetentionTime=Controls the retention time of full/slow SQL records ResultType.EnableThreadPool=Controls whether to use the thread pool feature ResultType.ThreadPoolAttr=Detailed attribute used to control thread pool functionality ResultType.LogStatement=Control logging SQL statements @@ -317,6 +317,12 @@ sql.threshold.svcTime.title =System service time sql.threshold.svcTime.detail =The system service time will affect the ioWait analysis of the XFS file system. When the threshold is exceeded, the disk needs to be checked sql.threshold.avgLoadNum.title =Load average sql.threshold.avgLoadNum.detail =The average load value affects the load analysis of the operating system. When the threshold is exceeded, a detailed analysis of the operating system is required +sql.threshold.dbMemUsageRate.title =Database memory usage rate +sql.threshold.dbMemUsageRate.detail =Database memory usage affects database memory analysis. When the threshold is exceeded, a detailed analysis of database memory is required +sql.threshold.sessionMemUsageRate.title =Database dynamic memory usage rate +sql.threshold.sessionMemUsageRate.detail =The utilization rate of database dynamic memory affects the analysis of database dynamic memory. When it exceeds the threshold, a detailed analysis of database dynamic memory is required +sql.threshold.shareMemUsageRate.title =Database shared memory usage rate +sql.threshold.shareMemUsageRate.detail =The usage rate of database shared memory affects the analysis of database shared memory. When it exceeds the threshold, a detailed analysis of database shared memory is required history.option.isCpu=CPU analysis history.option.isIo=IO analysis @@ -489,6 +495,109 @@ sql.RandomPageCost.detail = Random in SSD scenarios_ Page_ The cost parameter is sql.RandomPageCost.suggest = Random in SSD scenarios_ Page_ The cost parameter is set to the default value of 4, and it is recommended to adjust it to threshold value sql.RandomPageCost.suggest.normal = Random in SSD scenarios_ Page_ The cost parameter is set to the default value of 4, and it is recommended to adjust it to threshold value sql.RandomPageCost.suggest.high = Random in SSD scenarios_ Page_ The cost parameter is set to the default value of 4, and it is recommended to adjust it to threshold value +ResultType.DbMemAnalysis = Database Memory Analysis +DbMemAnalysis.tip = According to the data analysis collected at {0} time, the current database memory usage rate {1}% has exceeded the set {2}% threshold, and memory resources are about to be exhausted. It is necessary to conduct a detailed analysis of the memory usage of the database, especially the usage of dynamic memory and shared memory, in order to take corresponding optimization measures. +DatabaseMemoryUsageTable.name = Database Memory Usage +DatabaseMemoryUsageTable.column.nodename = nodename +DatabaseMemoryUsageTable.column.memorytype = memorytype +DatabaseMemoryUsageTable.column.memorymbytes = memorymbytes +sql.DbMemAnalysis.title = Database Memory Analysis +sql.DbMemAnalysis.title.normal = Database Memory Analysis +sql.DbMemAnalysis.title.high = Database Memory Analysis +sql.DbMemAnalysis.detail = This diagnostic item aims to determine whether the database memory has exceeded the set threshold by querying the current usage of database memory. When the database memory is insufficient, it may affect performance and even lead to database crashes in severe cases. \n Database memory usage rate=current memory size used by the database process (process_used_memory) divided by the maximum memory set by the parameter (x_process_mamory) * 100% +sql.DbMemAnalysis.suggest = According to the data analysis collected at {0} time, the current database memory usage rate {1}% has exceeded the set {2}% threshold, and memory resources are about to be exhausted. It is necessary to conduct a detailed analysis of the memory usage of the database, especially the usage of dynamic memory and shared memory, in order to take corresponding optimization measures. +sql.DbMemAnalysis.suggest.normal = According to the data analysis collected at {0} time, the current database memory usage rate {1}% no exceeded the set {2}% threshold, the database memory usage is normal. +sql.DbMemAnalysis.suggest.high = According to the data analysis collected at {0} time, the current database memory usage rate {1}% has exceeded the set {2}% threshold, and memory resources are about to be exhausted. It is necessary to conduct a detailed analysis of the memory usage of the database, especially the usage of dynamic memory and shared memory, in order to take corresponding optimization measures. +ResultType.DbDynamicMemory = Dynamic memory usage is too high +DbDynamicMemory.tip = According to the data analysis collected at {0} time, the current dynamic memory usage rate {1}% has exceeded the set {2}% threshold, indicating that the database memory is mainly occupied by dynamic memory. A detailed analysis of the usage of dynamic memory is needed to check if there are any abnormal sessions of SQL occupying too much dynamic memory, or if there is a memory leak causing abnormal growth of dynamic memory. +DbDynamicMemoryTable.name = Database dynamic memory usage +DbDynamicMemoryTable.column.totalsize = totalsize +DbDynamicMemoryTable.column.freesize = freesize +DbDynamicMemoryTable.column.usedsize = usedsize +DbDynamicMemoryTable.column.process_used_memory = process_used_memory +sql.DbDynamicMemory.title = Dynamic memory usage is too high +sql.DbDynamicMemory.title.normal = Dynamic memory usage is too high +sql.DbDynamicMemory.title.high = Dynamic memory usage is too high +sql.DbDynamicMemory.detail = This diagnostic item aims to check whether the database memory is mainly occupied by dynamic memory by querying the current usage of dynamic memory to determine if it exceeds the set threshold. If the dynamic memory usage is too high, it may lead to a decrease in database performance and even affect system stability. This analysis helps to promptly identify potential issues and further investigate whether dynamic memory usage abnormalities are caused by abnormal sessions, excessively high SQL queries, or memory leaks. \n Dynamic memory utilization=Used dynamic memory size (usedsize) divided by the current memory size used by the database process (process_used_memory) * 100% +sql.DbDynamicMemory.suggest = According to the data analysis collected at {0} time, the current dynamic memory usage rate {1}% has exceeded the set {2}% threshold, indicating that the database memory is mainly occupied by dynamic memory. A detailed analysis of the usage of dynamic memory is needed to check if there are any abnormal sessions of SQL occupying too much dynamic memory, or if there is a memory leak causing abnormal growth of dynamic memory. +sql.DbDynamicMemory.suggest.normal = According to the data analysis collected at {0} time, the current dynamic memory usage rate {1}% no exceeded the set {2}% threshold, the database dynamic memory usage is normal. +sql.DbDynamicMemory.suggest.high = According to the data analysis collected at {0} time, the current dynamic memory usage rate {1}% has exceeded the set {2}% threshold, indicating that the database memory is mainly occupied by dynamic memory. A detailed analysis of the usage of dynamic memory is needed to check if there are any abnormal sessions of SQL occupying too much dynamic memory, or if there is a memory leak causing abnormal growth of dynamic memory. +ResultType.SqlUseDynamicMem = Abnormal SQL occupies too much dynamic memory +SqlUseDynamicMem.tip = The following table shows the dynamic memory usage of the top 10 SQL queries. It is recommended to focus on analyzing SQL statements that consume a large amount of dynamic memory, identify potential performance bottlenecks, optimize queries or adjust execution plans to reduce memory consumption and improve system performance. +SqlUseDynamicMemTable.name = SQL uses dynamic memory usage +SqlUseDynamicMemTable.column.totalsize = totalsize +SqlUseDynamicMemTable.column.freesize = freesize +SqlUseDynamicMemTable.column.usedsize = usedsize +SqlUseDynamicMemTable.column.query = query +SqlUseDynamicMemTable.column.sessionid = sessionid +sql.SqlUseDynamicMem.title = Abnormal SQL occupies too much dynamic memory +sql.SqlUseDynamicMem.title.normal = Abnormal SQL occupies too much dynamic memory +sql.SqlUseDynamicMem.title.high = Abnormal SQL occupies too much dynamic memory +sql.SqlUseDynamicMem.detail = This diagnostic item queries the dynamic memory usage of the current session and groups it according to SQL statements, sorted in descending order by the amount of memory used. It is recommended to start with SQL queries with high memory usage and analyze whether there are problems with low execution efficiency or excessive resource consumption. Focus on investigating these high memory consuming SQL statements and identifying potential performance bottlenecks. By optimizing query statements or adjusting related configurations, memory usage can be effectively reduced, query efficiency can be improved, and overall system performance and stability can be enhanced. +sql.SqlUseDynamicMem.suggest = The following table shows the dynamic memory usage of the top 10 SQL queries. It is recommended to focus on analyzing SQL statements that consume a large amount of dynamic memory, identify potential performance bottlenecks, optimize queries or adjust execution plans to reduce memory consumption and improve system performance. +sql.SqlUseDynamicMem.suggest.normal = The following table shows the dynamic memory usage of the top 10 SQL queries. It is recommended to focus on analyzing SQL statements that consume a large amount of dynamic memory, identify potential performance bottlenecks, optimize queries or adjust execution plans to reduce memory consumption and improve system performance. +sql.SqlUseDynamicMem.suggest.high = The following table shows the dynamic memory usage of the top 10 SQL queries. It is recommended to focus on analyzing SQL statements that consume a large amount of dynamic memory, identify potential performance bottlenecks, optimize queries or adjust execution plans to reduce memory consumption and improve system performance. +ResultType.DbMemLeak = Dynamic memory leakage +DbMemLeak.tip = The current display shows the situation of unreleased memory in the TOP 10 call stack. It is recommended to focus on analyzing call stacks with large unreleased memory to identify potential memory leakage issues. By thoroughly examining the memory allocation and release logic of these call stacks, possible memory leaks can be effectively identified and fixed, thereby reducing memory consumption and improving system performance and stability. +DbMemLeakTable.name = Call stack information for unreleased memory +DbMemLeakTable.column.timePoint = timePoint +DbMemLeakTable.column.stackInfo = stackInfo +DbMemLeakTable.column.leakSize = leakSize +DbMemLeakTable.column.leakCount = leakCount +DbMemLeakChart.name = Database memory leakage situation +DbMemLeakChart.unit = byte +DbMemLeakChart.data = Total unreleased memory size +sql.DbMemLeak.title = Dynamic memory leakage +sql.DbMemLeak.title.normal = Dynamic memory leakage +sql.DbMemLeak.title.high = Dynamic memory leakage +sql.DbMemLeak.detail = This diagnostic item aims to detect memory leakage issues and prevent them from causing excessive dynamic memory usage. By using eBPF technology, analyze the memory requests and releases in the database kernel call stack during SQL diagnosis, and identify whether there are unreleased memory resources. For call stacks that may cause memory leaks, it is recommended to conduct a thorough analysis of their memory allocation and release processes, and take corresponding optimization measures to reduce memory usage and improve overall system performance and stability. +sql.DbMemLeak.suggest = The current display shows the situation of unreleased memory in the TOP 10 call stack. It is recommended to focus on analyzing call stacks with large unreleased memory to identify potential memory leakage issues. By thoroughly examining the memory allocation and release logic of these call stacks, possible memory leaks can be effectively identified and fixed, thereby reducing memory consumption and improving system performance and stability. +sql.DbMemLeak.suggest.normal = The current display shows the situation of unreleased memory in the TOP 10 call stack. It is recommended to focus on analyzing call stacks with large unreleased memory to identify potential memory leakage issues. By thoroughly examining the memory allocation and release logic of these call stacks, possible memory leaks can be effectively identified and fixed, thereby reducing memory consumption and improving system performance and stability. +sql.DbMemLeak.suggest.high = The current display shows the situation of unreleased memory in the TOP 10 call stack. It is recommended to focus on analyzing call stacks with large unreleased memory to identify potential memory leakage issues. By thoroughly examining the memory allocation and release logic of these call stacks, possible memory leaks can be effectively identified and fixed, thereby reducing memory consumption and improving system performance and stability. +ResultType.DbShareMemory = Shared memory usage is too high +DbShareMemory.tip = According to the data analysis collected at {0} time, the current shared memory usage rate {1}% has exceeded the set {2}% threshold, indicating that the database memory is mainly occupied by shared memory. A detailed analysis of the usage of shared memory is needed to check for any abnormal context where excessive usage of shared memory leads to abnormal growth of shared memory. +DbShareMemoryTable.name = Database shared memory usage +DbShareMemoryTable.column.totalsize = totalsize +DbShareMemoryTable.column.freesize = freesize +DbShareMemoryTable.column.usedsize = usedsize +DbShareMemoryTable.column.process_used_memory = process_used_memory +sql.DbShareMemory.title = Shared memory usage is too high +sql.DbShareMemory.title.normal = Shared memory usage is too high +sql.DbShareMemory.title.high = Shared memory usage is too high +sql.DbShareMemory.detail = This diagnostic item aims to check whether the database memory is mainly occupied by shared memory by querying the current usage of shared memory to determine if it exceeds the set threshold. If the shared memory usage is too high, it may lead to a decrease in database performance and even affect system stability. This analysis helps to promptly identify potential issues and further investigate whether abnormal usage of shared memory is caused by abnormal context or memory leaks. \n Shared memory usage rate=Used shared memory size (usedsize) divided by the current memory size used by the database process (process_used_memory) * 100% +sql.DbShareMemory.suggest = According to the data analysis collected at {0} time, the current shared memory usage rate {1}% has exceeded the set {2}% threshold, indicating that the database memory is mainly occupied by shared memory. A detailed analysis of the usage of shared memory is needed to check for any abnormal context where excessive usage of shared memory leads to abnormal growth of shared memory. +sql.DbShareMemory.suggest.normal = According to the data analysis collected at {0} time, the current shared memory usage rate {1}% has exceeded the set {2}% threshold, the database shared memory usage is normal. +sql.DbShareMemory.suggest.high = According to the data analysis collected at {0} time, the current shared memory usage rate {1}% has exceeded the set {2}% threshold, indicating that the database memory is mainly occupied by shared memory. A detailed analysis of the usage of shared memory is needed to check for any abnormal context where excessive usage of shared memory leads to abnormal growth of shared memory. +ResultType.ContextUseShareMem = Context usage shared memory too high +ContextUseShareMem.tip = The current display shows the use of shared memory in the TOP 10 contexts. It is recommended to focus on analyzing contexts that consume a large amount of shared memory to identify potential resource usage anomalies. By analyzing the shared memory usage patterns of these contexts in depth, it can be discovered whether there is unreasonable memory allocation or resource competition, thereby optimizing memory usage efficiency. Further optimization measures can help alleviate the burden of shared memory, improve system performance and response speed. +ContextUseShareMemTable.name = Context usage shared memory usage +ContextUseShareMemTable.column.totalsize = totalsize +ContextUseShareMemTable.column.freesize = freesize +ContextUseShareMemTable.column.usedsize = usedsize +ContextUseShareMemTable.column.contextname = contextname +ContextUseShareMemTable.column.count = count +sql.ContextUseShareMem.title = Context usage shared memory too high +sql.ContextUseShareMem.title.normal = Context usage shared memory too high +sql.ContextUseShareMem.title.high = Context usage shared memory too high +sql.ContextUseShareMem.detail = This diagnostic item identifies abnormal shared memory usage by querying the shared memory usage of the context, grouping them according to the context, and sorting them in descending order based on the amount of shared memory used. Analyzing these abnormal situations may be due to abnormal growth of shared memory caused by factors such as context switching, inter process communication, or resource competition. It is recommended to prioritize checking these abnormal contexts and optimize system configuration or adjust resource allocation based on analysis results to ensure reasonable utilization of shared memory, thereby improving system performance, stability, and resource utilization efficiency. +sql.ContextUseShareMem.suggest = The current display shows the use of shared memory in the TOP 10 contexts. It is recommended to focus on analyzing contexts that consume a large amount of shared memory to identify potential resource usage anomalies. By analyzing the shared memory usage patterns of these contexts in depth, it can be discovered whether there is unreasonable memory allocation or resource competition, thereby optimizing memory usage efficiency. Further optimization measures can help alleviate the burden of shared memory, improve system performance and response speed. +sql.ContextUseShareMem.suggest.normal = The current display shows the use of shared memory in the TOP 10 contexts. It is recommended to focus on analyzing contexts that consume a large amount of shared memory to identify potential resource usage anomalies. By analyzing the shared memory usage patterns of these contexts in depth, it can be discovered whether there is unreasonable memory allocation or resource competition, thereby optimizing memory usage efficiency. Further optimization measures can help alleviate the burden of shared memory, improve system performance and response speed. +sql.ContextUseShareMem.suggest.high = The current display shows the use of shared memory in the TOP 10 contexts. It is recommended to focus on analyzing contexts that consume a large amount of shared memory to identify potential resource usage anomalies. By analyzing the shared memory usage patterns of these contexts in depth, it can be discovered whether there is unreasonable memory allocation or resource competition, thereby optimizing memory usage efficiency. Further optimization measures can help alleviate the burden of shared memory, improve system performance and response speed. +ResultType.MemoryAccumulation = Shared memory, memory accumulation +MemoryAccumulation.tip = The current display shows detailed information on memory requests for the first 10 contexts that use shared memory. It is recommended to focus on analyzing contexts with large memory requests to identify whether there are memory leaks or unreleased situations. Through in-depth analysis of the code, the root cause of memory accumulation can be identified, thereby optimizing the code and improving the overall performance of the system. +MemoryAccumulationTable.name = Details of context request for memory +MemoryAccumulationTable.column.contextname = contextname +MemoryAccumulationTable.column.file = file +MemoryAccumulationTable.column.line = line +MemoryAccumulationTable.column.size = size +sql.MemoryAccumulation.title = Details of context request for memory +sql.MemoryAccumulation.title.normal = Details of context request for memory +sql.MemoryAccumulation.title.high = Details of context request for memory +sql.MemoryAccumulation.detail = This diagnostic item uses detailed information about shared memory usage by querying the context, covering the file, line number, and size of each memory request (for memory requests with the same file and line number, the size will be accumulated). By analyzing these detailed information, it is possible to effectively identify whether there are memory accumulation issues caused by unreleased memory in the code, thereby helping developers discover potential memory leak risks, optimize memory management, and improve system stability and performance. \n ote: The diagnostic item is obtained from the openGauss view and does not support release version miniaturization scenarios. And it must have either the Administrator or Monitor admin permissions. +sql.MemoryAccumulation.suggest = The current display shows detailed information on memory requests for the first 10 contexts that use shared memory. It is recommended to focus on analyzing contexts with large memory requests to identify whether there are memory leaks or unreleased situations. Through in-depth analysis of the code, the root cause of memory accumulation can be identified, thereby optimizing the code and improving the overall performance of the system. +sql.MemoryAccumulation.suggest.normal = The current display shows detailed information on memory requests for the first 10 contexts that use shared memory. It is recommended to focus on analyzing contexts with large memory requests to identify whether there are memory leaks or unreleased situations. Through in-depth analysis of the code, the root cause of memory accumulation can be identified, thereby optimizing the code and improving the overall performance of the system. +sql.MemoryAccumulation.suggest.high = The current display shows detailed information on memory requests for the first 10 contexts that use shared memory. It is recommended to focus on analyzing contexts with large memory requests to identify whether there are memory leaks or unreleased situations. Through in-depth analysis of the code, the root cause of memory accumulation can be identified, thereby optimizing the code and improving the overall performance of the system. + history.AspAnalysis.title=Average CPU usage of database processes history.AspAnalysis.title.normal=The database process CPU did not experience second level jitter diff --git a/plugins/observability-sql-diagnosis/src/main/resources/messages_zh_CN.properties b/plugins/observability-sql-diagnosis/src/main/resources/messages_zh_CN.properties index cd59afff9..d8cff1434 100644 --- a/plugins/observability-sql-diagnosis/src/main/resources/messages_zh_CN.properties +++ b/plugins/observability-sql-diagnosis/src/main/resources/messages_zh_CN.properties @@ -318,6 +318,12 @@ sql.threshold.svcTime.title =\u7CFB\u7EDF\u670D\u52A1\u65F6\u95F4 sql.threshold.svcTime.detail =\u7CFB\u7EDF\u670D\u52A1\u65F6\u95F4\u4F1A\u5F71\u54CDXFS\u6587\u4EF6\u7CFB\u7EDFioWait\u5206\u6790\uFF0C\u5F53\u8D85\u8FC7\u9608\u503C\u9700\u8981\u68C0\u67E5\u78C1\u76D8 sql.threshold.avgLoadNum.title =\u8D1F\u8F7D\u5E73\u5747\u503C sql.threshold.avgLoadNum.detail =\u8D1F\u8F7D\u5E73\u5747\u503C\u5F71\u54CD\u64CD\u4F5C\u7CFB\u7EDF\u8D1F\u8F7D\u5206\u6790\uFF0C\u5F53\u8D85\u8FC7\u9608\u503C\u9700\u8981\u5BF9\u64CD\u4F5C\u7CFB\u7EDF\u8FDB\u884C\u8BE6\u7EC6\u5206\u6790 +sql.threshold.dbMemUsageRate.title =\u6570\u636E\u5E93\u5185\u5B58\u4F7F\u7528\u7387 +sql.threshold.dbMemUsageRate.detail =\u6570\u636E\u5E93\u5185\u5B58\u4F7F\u7528\u7387\u5F71\u54CD\u6570\u636E\u5E93\u5185\u5B58\u5206\u6790\uFF0C\u5F53\u8D85\u8FC7\u9608\u503C\u9700\u8981\u5BF9\u6570\u636E\u5E93\u5185\u5B58\u8FDB\u884C\u8BE6\u7EC6\u5206\u6790 +sql.threshold.sessionMemUsageRate.title =\u6570\u636E\u5E93\u52A8\u6001\u5185\u5B58\u4F7F\u7528\u7387 +sql.threshold.sessionMemUsageRate.detail =\u6570\u636E\u5E93\u52A8\u6001\u5185\u5B58\u4F7F\u7528\u7387\u5F71\u54CD\u6570\u636E\u5E93\u52A8\u6001\u5185\u5B58\u5206\u6790\uFF0C\u5F53\u8D85\u8FC7\u9608\u503C\u9700\u8981\u5BF9\u6570\u636E\u5E93\u52A8\u6001\u5185\u5B58\u8FDB\u884C\u8BE6\u7EC6\u5206\u6790 +sql.threshold.shareMemUsageRate.title =\u6570\u636E\u5E93\u5171\u4EAB\u5185\u5B58\u4F7F\u7528\u7387 +sql.threshold.shareMemUsageRate.detail =\u6570\u636E\u5E93\u5171\u4EAB\u5185\u5B58\u4F7F\u7528\u7387\u5F71\u54CD\u6570\u636E\u5E93\u5171\u4EAB\u5185\u5B58\u5206\u6790\uFF0C\u5F53\u8D85\u8FC7\u9608\u503C\u9700\u8981\u5BF9\u6570\u636E\u5E93\u5171\u4EAB\u5185\u5B58\u8FDB\u884C\u8BE6\u7EC6\u5206\u6790 history.option.isCpu=CPU\u5206\u6790 history.option.isIo=IO\u5206\u6790 @@ -490,6 +496,109 @@ sql.RandomPageCost.detail = ssd\u573A\u666F\u4E0Brandom_page_cost\u53C2\u6570\u5 sql.RandomPageCost.suggest = ssd\u573A\u666F\u4E0Brandom_page_cost\u53C2\u6570\u4E3A\u9ED8\u8BA4\u503C4\uFF0C\u5EFA\u8BAE\u8C03\u6574\u4E3A\u9608\u503C sql.RandomPageCost.suggest.normal = ssd\u573A\u666F\u4E0Brandom_page_cost\u53C2\u6570\u4E3A\u9ED8\u8BA4\u503C4\uFF0C\u5EFA\u8BAE\u8C03\u6574\u4E3A\u9608\u503C sql.RandomPageCost.suggest.high = ssd\u573A\u666F\u4E0Brandom_page_cost\u53C2\u6570\u4E3A\u9ED8\u8BA4\u503C4\uFF0C\u5EFA\u8BAE\u8C03\u6574\u4E3A\u9608\u503C +ResultType.DbMemAnalysis = \u6570\u636E\u5E93\u5185\u5B58\u5206\u6790 +DbMemAnalysis.tip = \u6839\u636E{0}\u65F6\u95F4\u91C7\u96C6\u7684\u6570\u636E\u5206\u6790\uFF0C\u5F53\u524D\u6570\u636E\u5E93\u5185\u5B58\u4F7F\u7528\u7387{1}%\u5DF2\u8D85\u8FC7\u8BBE\u5B9A\u7684{2}%\u9608\u503C\uFF0C\u5185\u5B58\u8D44\u6E90\u5373\u5C06\u8017\u5C3D\u3002\u9700\u8981\u5BF9\u6570\u636E\u5E93\u7684\u5185\u5B58\u4F7F\u7528\u60C5\u51B5\u8FDB\u884C\u8BE6\u7EC6\u5206\u6790\uFF0C\u7279\u522B\u662F\u52A8\u6001\u5185\u5B58\u548C\u5171\u4EAB\u5185\u5B58\u7684\u4F7F\u7528\u60C5\u51B5\uFF0C\u4EE5\u4FBF\u91C7\u53D6\u76F8\u5E94\u7684\u4F18\u5316\u63AA\u65BD\u3002 +DatabaseMemoryUsageTable.name = \u6570\u636E\u5E93\u5185\u5B58\u4F7F\u7528\u60C5\u51B5 +DatabaseMemoryUsageTable.column.nodename = \u8282\u70B9\u540D\u79F0 +DatabaseMemoryUsageTable.column.memorytype = \u5185\u5B58\u7C7B\u578B +DatabaseMemoryUsageTable.column.memorymbytes = \u5185\u5B58\u7C7B\u578B\u5206\u914D\u5185\u5B58\u7684\u5927\u5C0F +sql.DbMemAnalysis.title = \u6570\u636E\u5E93\u5185\u5B58\u5206\u6790 +sql.DbMemAnalysis.title.normal = \u6570\u636E\u5E93\u5185\u5B58\u5206\u6790 +sql.DbMemAnalysis.title.high = \u6570\u636E\u5E93\u5185\u5B58\u5206\u6790 +sql.DbMemAnalysis.detail = \u8BE5\u8BCA\u65AD\u9879\u65E8\u5728\u901A\u8FC7\u67E5\u8BE2\u5F53\u524D\u65F6\u523B\u5DF2\u4F7F\u7528\u7684\u6570\u636E\u5E93\u5185\u5B58\u5360\u6BD4\uFF0C\u68C0\u67E5\u662F\u5426\u8D85\u8FC7\u8BBE\u5B9A\u9608\u503C\uFF0C\u4ECE\u800C\u5224\u65AD\u6570\u636E\u5E93\u5185\u5B58\u662F\u5426\u8D85\u9650\u3002\u5F53\u6570\u636E\u5E93\u5185\u5B58\u4E0D\u8DB3\u65F6\uFF0C\u53EF\u80FD\u4F1A\u5F71\u54CD\u6027\u80FD\uFF0C\u4E25\u91CD\u60C5\u51B5\u4E0B\u751A\u81F3\u5BFC\u81F4\u6570\u636E\u5E93\u5D29\u6E83\u3002\n \u6570\u636E\u5E93\u5185\u5B58\u4F7F\u7528\u7387=\u6570\u636E\u5E93\u8FDB\u7A0B\u5F53\u524D\u4F7F\u7528\u7684\u5185\u5B58\u5927\u5C0F\uFF08process_used_memory\uFF09 / \u53C2\u6570\u8BBE\u7F6E\u7684\u6700\u5927\u5185\u5B58 \uFF08max_process_memory\uFF09* 100% +sql.DbMemAnalysis.suggest = \u6839\u636E{0}\u65F6\u95F4\u91C7\u96C6\u7684\u6570\u636E\u5206\u6790\uFF0C\u5F53\u524D\u6570\u636E\u5E93\u5185\u5B58\u4F7F\u7528\u7387{1}%\u5DF2\u8D85\u8FC7\u8BBE\u5B9A\u7684{2}%\u9608\u503C\uFF0C\u5185\u5B58\u8D44\u6E90\u5373\u5C06\u8017\u5C3D\u3002\u9700\u8981\u5BF9\u6570\u636E\u5E93\u7684\u5185\u5B58\u4F7F\u7528\u60C5\u51B5\u8FDB\u884C\u8BE6\u7EC6\u5206\u6790\uFF0C\u7279\u522B\u662F\u52A8\u6001\u5185\u5B58\u548C\u5171\u4EAB\u5185\u5B58\u7684\u4F7F\u7528\u60C5\u51B5\uFF0C\u4EE5\u4FBF\u91C7\u53D6\u76F8\u5E94\u7684\u4F18\u5316\u63AA\u65BD\u3002 +sql.DbMemAnalysis.suggest.normal = \u6839\u636E{0}\u65F6\u95F4\u91C7\u96C6\u7684\u6570\u636E\u5206\u6790\uFF0C\u5F53\u524D\u6570\u636E\u5E93\u5185\u5B58\u4F7F\u7528\u7387{1}%\u672A\u8D85\u8FC7\u8BBE\u5B9A\u7684{2}%\u9608\u503C\uFF0C\u6570\u636E\u5E93\u5185\u5B58\u4F7F\u7528\u6B63\u5E38\u3002 +sql.DbMemAnalysis.suggest.high = \u6839\u636E{0}\u65F6\u95F4\u91C7\u96C6\u7684\u6570\u636E\u5206\u6790\uFF0C\u5F53\u524D\u6570\u636E\u5E93\u5185\u5B58\u4F7F\u7528\u7387{1}%\u5DF2\u8D85\u8FC7\u8BBE\u5B9A\u7684{2}%\u9608\u503C\uFF0C\u5185\u5B58\u8D44\u6E90\u5373\u5C06\u8017\u5C3D\u3002\u9700\u8981\u5BF9\u6570\u636E\u5E93\u7684\u5185\u5B58\u4F7F\u7528\u60C5\u51B5\u8FDB\u884C\u8BE6\u7EC6\u5206\u6790\uFF0C\u7279\u522B\u662F\u52A8\u6001\u5185\u5B58\u548C\u5171\u4EAB\u5185\u5B58\u7684\u4F7F\u7528\u60C5\u51B5\uFF0C\u4EE5\u4FBF\u91C7\u53D6\u76F8\u5E94\u7684\u4F18\u5316\u63AA\u65BD\u3002 +ResultType.DbDynamicMemory = \u52A8\u6001\u5185\u5B58\u4F7F\u7528\u8FC7\u9AD8 +DbDynamicMemory.tip = \u6839\u636E{0}\u65F6\u95F4\u91C7\u96C6\u7684\u6570\u636E\u5206\u6790\uFF0C\u5F53\u524D\u52A8\u6001\u5185\u5B58\u4F7F\u7528\u7387{1}%\u5DF2\u8D85\u8FC7\u8BBE\u5B9A\u7684{2}%\u9608\u503C\uFF0C\u8868\u660E\u6570\u636E\u5E93\u5185\u5B58\u4E3B\u8981\u88AB\u52A8\u6001\u5185\u5B58\u5360\u7528\u3002\u9700\u8981\u5BF9\u52A8\u6001\u5185\u5B58\u4F7F\u7528\u60C5\u51B5\u8FDB\u884C\u8BE6\u7EC6\u5206\u6790\uFF0C\u68C0\u67E5\u662F\u5426\u5B58\u5728\u5F02\u5E38\u4F1A\u8BDD\u7684 SQL \u5360\u7528\u8FC7\u591A\u52A8\u6001\u5185\u5B58\uFF0C\u6216\u662F\u5426\u53D1\u751F\u4E86\u5185\u5B58\u6CC4\u6F0F\u5BFC\u81F4\u52A8\u6001\u5185\u5B58\u589E\u957F\u5F02\u5E38\u3002 +DbDynamicMemoryTable.name = \u6570\u636E\u5E93\u52A8\u6001\u5185\u5B58\u4F7F\u7528\u60C5\u51B5 +DbDynamicMemoryTable.column.totalsize = \u603B\u7684\u52A8\u6001\u5185\u5B58 +DbDynamicMemoryTable.column.freesize = \u5DF2\u91CA\u653E\u7684\u52A8\u6001\u5185\u5B58 +DbDynamicMemoryTable.column.usedsize = \u5DF2\u4F7F\u7528\u7684\u52A8\u6001\u5185\u5B58 +DbDynamicMemoryTable.column.process_used_memory = \u6570\u636E\u5E93\u8FDB\u7A0B\u5F53\u524D\u4F7F\u7528\u7684\u5185\u5B58 +sql.DbDynamicMemory.title = \u52A8\u6001\u5185\u5B58\u4F7F\u7528\u8FC7\u9AD8 +sql.DbDynamicMemory.title.normal = \u52A8\u6001\u5185\u5B58\u4F7F\u7528\u8FC7\u9AD8 +sql.DbDynamicMemory.title.high = \u52A8\u6001\u5185\u5B58\u4F7F\u7528\u8FC7\u9AD8 +sql.DbDynamicMemory.detail = \u8BE5\u8BCA\u65AD\u9879\u65E8\u5728\u901A\u8FC7\u67E5\u8BE2\u5F53\u524D\u65F6\u523B\u5DF2\u4F7F\u7528\u7684\u52A8\u6001\u5185\u5B58\u5360\u6BD4\uFF0C\u5224\u65AD\u662F\u5426\u8D85\u8FC7\u8BBE\u5B9A\u7684\u9608\u503C\uFF0C\u4ECE\u800C\u68C0\u67E5\u6570\u636E\u5E93\u5185\u5B58\u662F\u5426\u4E3B\u8981\u88AB\u52A8\u6001\u5185\u5B58\u5360\u7528\u3002\u5982\u679C\u52A8\u6001\u5185\u5B58\u5360\u7528\u8FC7\u9AD8\uFF0C\u53EF\u80FD\u4F1A\u5BFC\u81F4\u6570\u636E\u5E93\u6027\u80FD\u4E0B\u964D\uFF0C\u751A\u81F3\u5F71\u54CD\u7CFB\u7EDF\u7A33\u5B9A\u6027\u3002\u6B64\u9879\u5206\u6790\u6709\u52A9\u4E8E\u53CA\u65F6\u53D1\u73B0\u6F5C\u5728\u95EE\u9898\uFF0C\u8FDB\u4E00\u6B65\u6392\u67E5\u662F\u5426\u7531\u4E8E\u5F02\u5E38\u4F1A\u8BDD\u3001\u8FC7\u9AD8\u7684 SQL \u67E5\u8BE2\u6216\u5185\u5B58\u6CC4\u6F0F\u7B49\u539F\u56E0\u5BFC\u81F4\u52A8\u6001\u5185\u5B58\u4F7F\u7528\u5F02\u5E38\u3002\n \u52A8\u6001\u5185\u5B58\u4F7F\u7528\u7387=\u5DF2\u4F7F\u7528\u7684\u52A8\u6001\u5185\u5B58\u5927\u5C0F \uFF08usedsize\uFF09/ \u6570\u636E\u5E93\u8FDB\u7A0B\u5F53\u524D\u4F7F\u7528\u7684\u5185\u5B58\u5927\u5C0F\uFF08process_used_memory\uFF09 * 100% +sql.DbDynamicMemory.suggest = \u6839\u636E{0}\u65F6\u95F4\u91C7\u96C6\u7684\u6570\u636E\u5206\u6790\uFF0C\u5F53\u524D\u52A8\u6001\u5185\u5B58\u4F7F\u7528\u7387{1}%\u5DF2\u8D85\u8FC7\u8BBE\u5B9A\u7684{2}%\u9608\u503C\uFF0C\u8868\u660E\u6570\u636E\u5E93\u5185\u5B58\u4E3B\u8981\u88AB\u52A8\u6001\u5185\u5B58\u5360\u7528\u3002\u9700\u8981\u5BF9\u52A8\u6001\u5185\u5B58\u4F7F\u7528\u60C5\u51B5\u8FDB\u884C\u8BE6\u7EC6\u5206\u6790\uFF0C\u68C0\u67E5\u662F\u5426\u5B58\u5728\u5F02\u5E38\u4F1A\u8BDD\u7684 SQL \u5360\u7528\u8FC7\u591A\u52A8\u6001\u5185\u5B58\uFF0C\u6216\u662F\u5426\u53D1\u751F\u4E86\u5185\u5B58\u6CC4\u6F0F\u5BFC\u81F4\u52A8\u6001\u5185\u5B58\u589E\u957F\u5F02\u5E38\u3002 +sql.DbDynamicMemory.suggest.normal = \u6839\u636E{0}\u65F6\u95F4\u91C7\u96C6\u7684\u6570\u636E\u5206\u6790\uFF0C\u5F53\u524D\u52A8\u6001\u5185\u5B58\u4F7F\u7528\u7387{1}%\u672A\u8D85\u8FC7\u8BBE\u5B9A\u7684{2}%\u9608\u503C\uFF0C\u6570\u636E\u5E93\u52A8\u6001\u5185\u5B58\u4F7F\u7528\u6B63\u5E38\u3002 +sql.DbDynamicMemory.suggest.high = \u6839\u636E{0}\u65F6\u95F4\u91C7\u96C6\u7684\u6570\u636E\u5206\u6790\uFF0C\u5F53\u524D\u52A8\u6001\u5185\u5B58\u4F7F\u7528\u7387{1}%\u5DF2\u8D85\u8FC7\u8BBE\u5B9A\u7684{2}%\u9608\u503C\uFF0C\u8868\u660E\u6570\u636E\u5E93\u5185\u5B58\u4E3B\u8981\u88AB\u52A8\u6001\u5185\u5B58\u5360\u7528\u3002\u9700\u8981\u5BF9\u52A8\u6001\u5185\u5B58\u4F7F\u7528\u60C5\u51B5\u8FDB\u884C\u8BE6\u7EC6\u5206\u6790\uFF0C\u68C0\u67E5\u662F\u5426\u5B58\u5728\u5F02\u5E38\u4F1A\u8BDD\u7684 SQL \u5360\u7528\u8FC7\u591A\u52A8\u6001\u5185\u5B58\uFF0C\u6216\u662F\u5426\u53D1\u751F\u4E86\u5185\u5B58\u6CC4\u6F0F\u5BFC\u81F4\u52A8\u6001\u5185\u5B58\u589E\u957F\u5F02\u5E38\u3002 +ResultType.SqlUseDynamicMem = \u5F02\u5E38SQL\u5360\u7528\u52A8\u6001\u5185\u5B58\u8FC7\u9AD8 +SqlUseDynamicMem.tip = \u4E0B\u8868\u5C55\u793A\u4E86TOP 10 SQL \u67E5\u8BE2\u7684\u52A8\u6001\u5185\u5B58\u4F7F\u7528\u60C5\u51B5\u3002\u5EFA\u8BAE\u91CD\u70B9\u5206\u6790\u90A3\u4E9B\u5360\u7528\u52A8\u6001\u5185\u5B58\u8F83\u5927\u7684 SQL \u8BED\u53E5\uFF0C\u627E\u51FA\u6F5C\u5728\u7684\u6027\u80FD\u74F6\u9888\uFF0C\u4F18\u5316\u67E5\u8BE2\u6216\u8C03\u6574\u6267\u884C\u8BA1\u5212\uFF0C\u4EE5\u51CF\u5C11\u5185\u5B58\u6D88\u8017\u548C\u63D0\u9AD8\u7CFB\u7EDF\u6027\u80FD\u3002 +SqlUseDynamicMemTable.name = SQL\u4F7F\u7528\u52A8\u6001\u5185\u5B58\u4F7F\u7528\u60C5\u51B5 +SqlUseDynamicMemTable.column.totalsize = \u603B\u7684\u52A8\u6001\u5185\u5B58 +SqlUseDynamicMemTable.column.freesize = \u5DF2\u91CA\u653E\u7684\u52A8\u6001\u5185\u5B58 +SqlUseDynamicMemTable.column.usedsize = \u5DF2\u4F7F\u7528\u7684\u52A8\u6001\u5185\u5B58 +SqlUseDynamicMemTable.column.query = SQL\u8BED\u53E5 +SqlUseDynamicMemTable.column.sessionid = \u4F1A\u8BDDID +sql.SqlUseDynamicMem.title = \u5F02\u5E38SQL\u5360\u7528\u52A8\u6001\u5185\u5B58\u8FC7\u9AD8 +sql.SqlUseDynamicMem.title.normal = \u5F02\u5E38SQL\u5360\u7528\u52A8\u6001\u5185\u5B58\u8FC7\u9AD8 +sql.SqlUseDynamicMem.title.high = \u5F02\u5E38SQL\u5360\u7528\u52A8\u6001\u5185\u5B58\u8FC7\u9AD8 +sql.SqlUseDynamicMem.detail = \u8BE5\u8BCA\u65AD\u9879\u901A\u8FC7\u67E5\u8BE2\u5F53\u524D\u4F1A\u8BDD\u7684\u52A8\u6001\u5185\u5B58\u4F7F\u7528\u60C5\u51B5\uFF0C\u5E76\u6839\u636E SQL \u8BED\u53E5\u8FDB\u884C\u5206\u7EC4\uFF0C\u6309\u5DF2\u4F7F\u7528\u7684\u5185\u5B58\u91CF\u964D\u5E8F\u6392\u5217\u3002\u5EFA\u8BAE\u4ECE\u5185\u5B58\u5360\u7528\u8F83\u9AD8\u7684 SQL \u67E5\u8BE2\u5165\u624B\uFF0C\u5206\u6790\u662F\u5426\u5B58\u5728\u6267\u884C\u6548\u7387\u4F4E\u4E0B\u6216\u8D44\u6E90\u6D88\u8017\u8FC7\u5927\u7684\u95EE\u9898\u3002\u91CD\u70B9\u6392\u67E5\u8FD9\u4E9B\u9AD8\u5185\u5B58\u5360\u7528\u7684 SQL \u8BED\u53E5\uFF0C\u627E\u51FA\u6F5C\u5728\u7684\u6027\u80FD\u74F6\u9888\u3002\u901A\u8FC7\u4F18\u5316\u67E5\u8BE2\u8BED\u53E5\u6216\u8C03\u6574\u76F8\u5173\u914D\u7F6E\uFF0C\u80FD\u591F\u6709\u6548\u51CF\u5C11\u5185\u5B58\u5360\u7528\uFF0C\u63D0\u9AD8\u67E5\u8BE2\u6548\u7387\uFF0C\u4ECE\u800C\u63D0\u5347\u7CFB\u7EDF\u7684\u6574\u4F53\u6027\u80FD\u548C\u7A33\u5B9A\u6027\u3002 +sql.SqlUseDynamicMem.suggest = \u4E0B\u8868\u5C55\u793A\u4E86TOP 10 SQL \u67E5\u8BE2\u7684\u52A8\u6001\u5185\u5B58\u4F7F\u7528\u60C5\u51B5\u3002\u5EFA\u8BAE\u91CD\u70B9\u5206\u6790\u90A3\u4E9B\u5360\u7528\u52A8\u6001\u5185\u5B58\u8F83\u5927\u7684 SQL \u8BED\u53E5\uFF0C\u627E\u51FA\u6F5C\u5728\u7684\u6027\u80FD\u74F6\u9888\uFF0C\u4F18\u5316\u67E5\u8BE2\u6216\u8C03\u6574\u6267\u884C\u8BA1\u5212\uFF0C\u4EE5\u51CF\u5C11\u5185\u5B58\u6D88\u8017\u548C\u63D0\u9AD8\u7CFB\u7EDF\u6027\u80FD\u3002 +sql.SqlUseDynamicMem.suggest.normal = \u4E0B\u8868\u5C55\u793A\u4E86TOP 10 SQL \u67E5\u8BE2\u7684\u52A8\u6001\u5185\u5B58\u4F7F\u7528\u60C5\u51B5\u3002\u5EFA\u8BAE\u91CD\u70B9\u5206\u6790\u90A3\u4E9B\u5360\u7528\u52A8\u6001\u5185\u5B58\u8F83\u5927\u7684 SQL \u8BED\u53E5\uFF0C\u627E\u51FA\u6F5C\u5728\u7684\u6027\u80FD\u74F6\u9888\uFF0C\u4F18\u5316\u67E5\u8BE2\u6216\u8C03\u6574\u6267\u884C\u8BA1\u5212\uFF0C\u4EE5\u51CF\u5C11\u5185\u5B58\u6D88\u8017\u548C\u63D0\u9AD8\u7CFB\u7EDF\u6027\u80FD\u3002 +sql.SqlUseDynamicMem.suggest.high = \u4E0B\u8868\u5C55\u793A\u4E86TOP 10 SQL \u67E5\u8BE2\u7684\u52A8\u6001\u5185\u5B58\u4F7F\u7528\u60C5\u51B5\u3002\u5EFA\u8BAE\u91CD\u70B9\u5206\u6790\u90A3\u4E9B\u5360\u7528\u52A8\u6001\u5185\u5B58\u8F83\u5927\u7684 SQL \u8BED\u53E5\uFF0C\u627E\u51FA\u6F5C\u5728\u7684\u6027\u80FD\u74F6\u9888\uFF0C\u4F18\u5316\u67E5\u8BE2\u6216\u8C03\u6574\u6267\u884C\u8BA1\u5212\uFF0C\u4EE5\u51CF\u5C11\u5185\u5B58\u6D88\u8017\u548C\u63D0\u9AD8\u7CFB\u7EDF\u6027\u80FD\u3002 +ResultType.DbMemLeak = \u52A8\u6001\u5185\u5B58\u5185\u5B58\u6CC4\u6F0F +DbMemLeak.tip = \u5F53\u524D\u663E\u793A\u7684\u662F TOP 10 \u8C03\u7528\u6808\u4E2D\u672A\u91CA\u653E\u5185\u5B58\u7684\u60C5\u51B5\u3002\u5EFA\u8BAE\u91CD\u70B9\u5206\u6790\u90A3\u4E9B\u672A\u91CA\u653E\u5185\u5B58\u8F83\u5927\u7684\u8C03\u7528\u6808\uFF0C\u4EE5\u4FBF\u53D1\u73B0\u6F5C\u5728\u7684\u5185\u5B58\u6CC4\u6F0F\u95EE\u9898\u3002\u901A\u8FC7\u6DF1\u5165\u68C0\u67E5\u8FD9\u4E9B\u8C03\u7528\u6808\u7684\u5185\u5B58\u5206\u914D\u4E0E\u91CA\u653E\u903B\u8F91\uFF0C\u53EF\u4EE5\u6709\u6548\u8BC6\u522B\u5E76\u4FEE\u590D\u53EF\u80FD\u7684\u5185\u5B58\u6CC4\u6F0F\uFF0C\u4ECE\u800C\u51CF\u5C11\u5185\u5B58\u6D88\u8017\uFF0C\u63D0\u5347\u7CFB\u7EDF\u6027\u80FD\u548C\u7A33\u5B9A\u6027\u3002 +DbMemLeakTable.name = \u672A\u91CA\u653E\u5185\u5B58\u7684\u8C03\u7528\u6808\u4FE1\u606F +DbMemLeakTable.column.timePoint = \u91C7\u6837\u65F6\u95F4 +DbMemLeakTable.column.stackInfo = \u8C03\u7528\u6808 +DbMemLeakTable.column.leakSize = \u672A\u91CA\u653E\u7684\u603B\u5185\u5B58\u5927\u5C0F +DbMemLeakTable.column.leakCount = \u7533\u8BF7\u5185\u5B58\u672A\u91CA\u653E\u7684\u6B21\u6570 +DbMemLeakChart.name = \u6570\u636E\u5E93\u5185\u5B58\u6CC4\u6F0F\u60C5\u51B5 +DbMemLeakChart.unit = \u5B57\u8282 +DbMemLeakChart.data = \u672A\u91CA\u653E\u7684\u603B\u5185\u5B58\u5927\u5C0F +sql.DbMemLeak.title = \u52A8\u6001\u5185\u5B58\u5185\u5B58\u6CC4\u6F0F +sql.DbMemLeak.title.normal = \u52A8\u6001\u5185\u5B58\u5185\u5B58\u6CC4\u6F0F +sql.DbMemLeak.title.high = \u52A8\u6001\u5185\u5B58\u5185\u5B58\u6CC4\u6F0F +sql.DbMemLeak.detail = \u8BE5\u8BCA\u65AD\u9879\u65E8\u5728\u68C0\u6D4B\u5185\u5B58\u6CC4\u6F0F\u95EE\u9898\uFF0C\u9632\u6B62\u5176\u5BFC\u81F4\u52A8\u6001\u5185\u5B58\u5360\u7528\u8FC7\u9AD8\u3002\u901A\u8FC7 eBPF \u6280\u672F\uFF0C\u5206\u6790 SQL \u8BCA\u65AD\u671F\u95F4\u6570\u636E\u5E93\u5185\u6838\u8C03\u7528\u6808\u4E2D\u7684\u5185\u5B58\u7533\u8BF7\u4E0E\u91CA\u653E\u60C5\u51B5\uFF0C\u80FD\u591F\u8BC6\u522B\u662F\u5426\u5B58\u5728\u672A\u91CA\u653E\u7684\u5185\u5B58\u8D44\u6E90\u3002\u5BF9\u4E8E\u53EF\u80FD\u5F15\u53D1\u5185\u5B58\u6CC4\u6F0F\u7684\u8C03\u7528\u6808\uFF0C\u5EFA\u8BAE\u6DF1\u5165\u5206\u6790\u5176\u5185\u5B58\u5206\u914D\u4E0E\u91CA\u653E\u8FC7\u7A0B\uFF0C\u5E76\u91C7\u53D6\u76F8\u5E94\u4F18\u5316\u63AA\u65BD\uFF0C\u4EE5\u51CF\u5C11\u5185\u5B58\u5360\u7528\u5E76\u63D0\u5347\u7CFB\u7EDF\u7684\u6574\u4F53\u6027\u80FD\u4E0E\u7A33\u5B9A\u6027\u3002 +sql.DbMemLeak.suggest = \u5F53\u524D\u663E\u793A\u7684\u662F TOP 10 \u8C03\u7528\u6808\u4E2D\u672A\u91CA\u653E\u5185\u5B58\u7684\u60C5\u51B5\u3002\u5EFA\u8BAE\u91CD\u70B9\u5206\u6790\u90A3\u4E9B\u672A\u91CA\u653E\u5185\u5B58\u8F83\u5927\u7684\u8C03\u7528\u6808\uFF0C\u4EE5\u4FBF\u53D1\u73B0\u6F5C\u5728\u7684\u5185\u5B58\u6CC4\u6F0F\u95EE\u9898\u3002\u901A\u8FC7\u6DF1\u5165\u68C0\u67E5\u8FD9\u4E9B\u8C03\u7528\u6808\u7684\u5185\u5B58\u5206\u914D\u4E0E\u91CA\u653E\u903B\u8F91\uFF0C\u53EF\u4EE5\u6709\u6548\u8BC6\u522B\u5E76\u4FEE\u590D\u53EF\u80FD\u7684\u5185\u5B58\u6CC4\u6F0F\uFF0C\u4ECE\u800C\u51CF\u5C11\u5185\u5B58\u6D88\u8017\uFF0C\u63D0\u5347\u7CFB\u7EDF\u6027\u80FD\u548C\u7A33\u5B9A\u6027\u3002 +sql.DbMemLeak.suggest.normal = \u5F53\u524D\u663E\u793A\u7684\u662F TOP 10 \u8C03\u7528\u6808\u4E2D\u672A\u91CA\u653E\u5185\u5B58\u7684\u60C5\u51B5\u3002\u5EFA\u8BAE\u91CD\u70B9\u5206\u6790\u90A3\u4E9B\u672A\u91CA\u653E\u5185\u5B58\u8F83\u5927\u7684\u8C03\u7528\u6808\uFF0C\u4EE5\u4FBF\u53D1\u73B0\u6F5C\u5728\u7684\u5185\u5B58\u6CC4\u6F0F\u95EE\u9898\u3002\u901A\u8FC7\u6DF1\u5165\u68C0\u67E5\u8FD9\u4E9B\u8C03\u7528\u6808\u7684\u5185\u5B58\u5206\u914D\u4E0E\u91CA\u653E\u903B\u8F91\uFF0C\u53EF\u4EE5\u6709\u6548\u8BC6\u522B\u5E76\u4FEE\u590D\u53EF\u80FD\u7684\u5185\u5B58\u6CC4\u6F0F\uFF0C\u4ECE\u800C\u51CF\u5C11\u5185\u5B58\u6D88\u8017\uFF0C\u63D0\u5347\u7CFB\u7EDF\u6027\u80FD\u548C\u7A33\u5B9A\u6027\u3002 +sql.DbMemLeak.suggest.high = \u5F53\u524D\u663E\u793A\u7684\u662F TOP 10 \u8C03\u7528\u6808\u4E2D\u672A\u91CA\u653E\u5185\u5B58\u7684\u60C5\u51B5\u3002\u5EFA\u8BAE\u91CD\u70B9\u5206\u6790\u90A3\u4E9B\u672A\u91CA\u653E\u5185\u5B58\u8F83\u5927\u7684\u8C03\u7528\u6808\uFF0C\u4EE5\u4FBF\u53D1\u73B0\u6F5C\u5728\u7684\u5185\u5B58\u6CC4\u6F0F\u95EE\u9898\u3002\u901A\u8FC7\u6DF1\u5165\u68C0\u67E5\u8FD9\u4E9B\u8C03\u7528\u6808\u7684\u5185\u5B58\u5206\u914D\u4E0E\u91CA\u653E\u903B\u8F91\uFF0C\u53EF\u4EE5\u6709\u6548\u8BC6\u522B\u5E76\u4FEE\u590D\u53EF\u80FD\u7684\u5185\u5B58\u6CC4\u6F0F\uFF0C\u4ECE\u800C\u51CF\u5C11\u5185\u5B58\u6D88\u8017\uFF0C\u63D0\u5347\u7CFB\u7EDF\u6027\u80FD\u548C\u7A33\u5B9A\u6027\u3002 +ResultType.DbShareMemory = \u5171\u4EAB\u5185\u5B58\u4F7F\u7528\u8FC7\u9AD8 +DbShareMemory.tip = \u6839\u636E{0}\u65F6\u95F4\u91C7\u96C6\u7684\u6570\u636E\u5206\u6790\uFF0C\u5F53\u524D\u5171\u4EAB\u5185\u5B58\u4F7F\u7528\u7387{1}%\u5DF2\u8D85\u8FC7\u8BBE\u5B9A\u7684{2}%\u9608\u503C\uFF0C\u8868\u660E\u6570\u636E\u5E93\u5185\u5B58\u4E3B\u8981\u88AB\u5171\u4EAB\u5185\u5B58\u5360\u7528\u3002\u9700\u8981\u5BF9\u5171\u4EAB\u5185\u5B58\u4F7F\u7528\u60C5\u51B5\u8FDB\u884C\u8BE6\u7EC6\u5206\u6790\uFF0C\u68C0\u67E5\u662F\u5426\u5B58\u5728\u5F02\u5E38\u4E0A\u4E0B\u6587\u4F7F\u7528\u5171\u4EAB\u5185\u5B58\u8FC7\u591A\u5BFC\u81F4\u5171\u4EAB\u5185\u5B58\u589E\u957F\u5F02\u5E38\u3002 +DbShareMemoryTable.name = \u6570\u636E\u5E93\u5171\u4EAB\u5185\u5B58\u4F7F\u7528\u60C5\u51B5 +DbShareMemoryTable.column.totalsize = \u603B\u7684\u5171\u4EAB\u5185\u5B58 +DbShareMemoryTable.column.freesize = \u5DF2\u91CA\u653E\u7684\u5171\u4EAB\u5185\u5B58 +DbShareMemoryTable.column.usedsize = \u5DF2\u4F7F\u7528\u7684\u5171\u4EAB\u5185\u5B58 +DbShareMemoryTable.column.process_used_memory = \u6570\u636E\u5E93\u8FDB\u7A0B\u5F53\u524D\u4F7F\u7528\u7684\u5185\u5B58 +sql.DbShareMemory.title = \u5171\u4EAB\u5185\u5B58\u4F7F\u7528\u8FC7\u9AD8 +sql.DbShareMemory.title.normal = \u5171\u4EAB\u5185\u5B58\u4F7F\u7528\u8FC7\u9AD8 +sql.DbShareMemory.title.high = \u5171\u4EAB\u5185\u5B58\u4F7F\u7528\u8FC7\u9AD8 +sql.DbShareMemory.detail = \u8BE5\u8BCA\u65AD\u9879\u65E8\u5728\u901A\u8FC7\u67E5\u8BE2\u5F53\u524D\u65F6\u523B\u5DF2\u4F7F\u7528\u7684\u5171\u4EAB\u5185\u5B58\u5360\u6BD4\uFF0C\u5224\u65AD\u662F\u5426\u8D85\u8FC7\u8BBE\u5B9A\u7684\u9608\u503C\uFF0C\u4ECE\u800C\u68C0\u67E5\u6570\u636E\u5E93\u5185\u5B58\u662F\u5426\u4E3B\u8981\u88AB\u5171\u4EAB\u5185\u5B58\u5360\u7528\u3002\u5982\u679C\u5171\u4EAB\u5185\u5B58\u5360\u7528\u8FC7\u9AD8\uFF0C\u53EF\u80FD\u4F1A\u5BFC\u81F4\u6570\u636E\u5E93\u6027\u80FD\u4E0B\u964D\uFF0C\u751A\u81F3\u5F71\u54CD\u7CFB\u7EDF\u7A33\u5B9A\u6027\u3002\u6B64\u9879\u5206\u6790\u6709\u52A9\u4E8E\u53CA\u65F6\u53D1\u73B0\u6F5C\u5728\u95EE\u9898\uFF0C\u8FDB\u4E00\u6B65\u6392\u67E5\u662F\u5426\u7531\u4E8E\u5F02\u5E38\u4E0A\u4E0B\u6587\u6216\u5185\u5B58\u6CC4\u6F0F\u7B49\u539F\u56E0\u5BFC\u81F4\u5171\u4EAB\u5185\u5B58\u4F7F\u7528\u5F02\u5E38\u3002\n \u5171\u4EAB\u5185\u5B58\u4F7F\u7528\u7387=\u5DF2\u4F7F\u7528\u7684\u5171\u4EAB\u5185\u5B58\u5927\u5C0F \uFF08usedsize\uFF09/ \u6570\u636E\u5E93\u8FDB\u7A0B\u5F53\u524D\u4F7F\u7528\u7684\u5185\u5B58\u5927\u5C0F\uFF08process_used_memory\uFF09 * 100% +sql.DbShareMemory.suggest = \u6839\u636E{0}\u65F6\u95F4\u91C7\u96C6\u7684\u6570\u636E\u5206\u6790\uFF0C\u5F53\u524D\u5171\u4EAB\u5185\u5B58\u4F7F\u7528\u7387{1}%\u5DF2\u8D85\u8FC7\u8BBE\u5B9A\u7684{2}%\u9608\u503C\uFF0C\u8868\u660E\u6570\u636E\u5E93\u5185\u5B58\u4E3B\u8981\u88AB\u5171\u4EAB\u5185\u5B58\u5360\u7528\u3002\u9700\u8981\u5BF9\u5171\u4EAB\u5185\u5B58\u4F7F\u7528\u60C5\u51B5\u8FDB\u884C\u8BE6\u7EC6\u5206\u6790\uFF0C\u68C0\u67E5\u662F\u5426\u5B58\u5728\u5F02\u5E38\u4E0A\u4E0B\u6587\u4F7F\u7528\u5171\u4EAB\u5185\u5B58\u8FC7\u591A\u5BFC\u81F4\u5171\u4EAB\u5185\u5B58\u589E\u957F\u5F02\u5E38\u3002 +sql.DbShareMemory.suggest.normal = \u6839\u636E{0}\u65F6\u95F4\u91C7\u96C6\u7684\u6570\u636E\u5206\u6790\uFF0C\u5F53\u524D\u5171\u4EAB\u5185\u5B58\u4F7F\u7528\u7387{1}%\u672A\u8D85\u8FC7\u8BBE\u5B9A\u7684{2}%\u9608\u503C\uFF0C\u6570\u636E\u5E93\u5171\u4EAB\u5185\u5B58\u4F7F\u7528\u6B63\u5E38\u3002 +sql.DbShareMemory.suggest.high = \u6839\u636E{0}\u65F6\u95F4\u91C7\u96C6\u7684\u6570\u636E\u5206\u6790\uFF0C\u5F53\u524D\u5171\u4EAB\u5185\u5B58\u4F7F\u7528\u7387{1}%\u5DF2\u8D85\u8FC7\u8BBE\u5B9A\u7684{2}%\u9608\u503C\uFF0C\u8868\u660E\u6570\u636E\u5E93\u5185\u5B58\u4E3B\u8981\u88AB\u5171\u4EAB\u5185\u5B58\u5360\u7528\u3002\u9700\u8981\u5BF9\u5171\u4EAB\u5185\u5B58\u4F7F\u7528\u60C5\u51B5\u8FDB\u884C\u8BE6\u7EC6\u5206\u6790\uFF0C\u68C0\u67E5\u662F\u5426\u5B58\u5728\u5F02\u5E38\u4E0A\u4E0B\u6587\u4F7F\u7528\u5171\u4EAB\u5185\u5B58\u8FC7\u591A\u5BFC\u81F4\u5171\u4EAB\u5185\u5B58\u589E\u957F\u5F02\u5E38\u3002 +ResultType.ContextUseShareMem = \u4E0A\u4E0B\u6587\u4F7F\u7528\u5171\u4EAB\u5185\u5B58\u8FC7\u9AD8 +ContextUseShareMem.tip = \u5F53\u524D\u663E\u793A\u7684\u662F TOP 10 \u4E0A\u4E0B\u6587\u4F7F\u7528\u5171\u4EAB\u5185\u5B58\u7684\u60C5\u51B5\u3002\u5EFA\u8BAE\u91CD\u70B9\u5206\u6790\u90A3\u4E9B\u5360\u7528\u5171\u4EAB\u5185\u5B58\u8F83\u5927\u7684\u4E0A\u4E0B\u6587\uFF0C\u4EE5\u8BC6\u522B\u6F5C\u5728\u7684\u8D44\u6E90\u5360\u7528\u5F02\u5E38\u3002\u901A\u8FC7\u6DF1\u5165\u5206\u6790\u8FD9\u4E9B\u4E0A\u4E0B\u6587\u7684\u5171\u4EAB\u5185\u5B58\u4F7F\u7528\u6A21\u5F0F\uFF0C\u53EF\u4EE5\u53D1\u73B0\u662F\u5426\u5B58\u5728\u4E0D\u5408\u7406\u7684\u5185\u5B58\u5206\u914D\u6216\u8D44\u6E90\u7ADE\u4E89\uFF0C\u4ECE\u800C\u4F18\u5316\u5185\u5B58\u4F7F\u7528\u6548\u7387\u3002\u8FDB\u4E00\u6B65\u7684\u4F18\u5316\u63AA\u65BD\u53EF\u5E2E\u52A9\u51CF\u8F7B\u5171\u4EAB\u5185\u5B58\u8D1F\u62C5\uFF0C\u63D0\u5347\u7CFB\u7EDF\u7684\u6027\u80FD\u548C\u54CD\u5E94\u901F\u5EA6\u3002 +ContextUseShareMemTable.name = \u4E0A\u4E0B\u6587\u4F7F\u7528\u5171\u4EAB\u5185\u5B58\u4F7F\u7528\u60C5\u51B5 +ContextUseShareMemTable.column.totalsize = \u603B\u7684\u5171\u4EAB\u5185\u5B58 +ContextUseShareMemTable.column.freesize = \u5DF2\u91CA\u653E\u7684\u5171\u4EAB\u5185\u5B58 +ContextUseShareMemTable.column.usedsize = \u5DF2\u4F7F\u7528\u7684\u5171\u4EAB\u5185\u5B58 +ContextUseShareMemTable.column.contextname = \u4E0A\u4E0B\u6587\u540D\u79F0 +ContextUseShareMemTable.column.count = \u6B21\u6570 +sql.ContextUseShareMem.title = \u4E0A\u4E0B\u6587\u4F7F\u7528\u5171\u4EAB\u5185\u5B58\u8FC7\u9AD8 +sql.ContextUseShareMem.title.normal = \u4E0A\u4E0B\u6587\u4F7F\u7528\u5171\u4EAB\u5185\u5B58\u8FC7\u9AD8 +sql.ContextUseShareMem.title.high = \u4E0A\u4E0B\u6587\u4F7F\u7528\u5171\u4EAB\u5185\u5B58\u8FC7\u9AD8 +sql.ContextUseShareMem.detail = \u8BE5\u8BCA\u65AD\u9879\u901A\u8FC7\u67E5\u8BE2\u4E0A\u4E0B\u6587\u7684\u5171\u4EAB\u5185\u5B58\u4F7F\u7528\u60C5\u51B5\uFF0C\u5E76\u6839\u636E\u4E0A\u4E0B\u6587\u8FDB\u884C\u5206\u7EC4\uFF0C\u6309\u5DF2\u4F7F\u7528\u7684\u5171\u4EAB\u5185\u5B58\u91CF\u964D\u5E8F\u6392\u5217\uFF0C\u4ECE\u800C\u8BC6\u522B\u51FA\u5F02\u5E38\u7684\u5171\u4EAB\u5185\u5B58\u4F7F\u7528\u60C5\u51B5\u3002\u5206\u6790\u8FD9\u4E9B\u5F02\u5E38\u60C5\u51B5\uFF0C\u53EF\u80FD\u662F\u7531\u4E8E\u4E0A\u4E0B\u6587\u5207\u6362\u3001\u8FDB\u7A0B\u95F4\u901A\u4FE1\u6216\u8D44\u6E90\u7ADE\u4E89\u7B49\u56E0\u7D20\u5BFC\u81F4\u7684\u5171\u4EAB\u5185\u5B58\u5F02\u5E38\u589E\u957F\u3002\u5EFA\u8BAE\u4F18\u5148\u68C0\u67E5\u8FD9\u4E9B\u5F02\u5E38\u4E0A\u4E0B\u6587\uFF0C\u5E76\u6839\u636E\u5206\u6790\u7ED3\u679C\u4F18\u5316\u7CFB\u7EDF\u914D\u7F6E\u6216\u8C03\u6574\u8D44\u6E90\u5206\u914D\uFF0C\u4EE5\u786E\u4FDD\u5171\u4EAB\u5185\u5B58\u5F97\u5230\u5408\u7406\u5229\u7528\uFF0C\u8FDB\u800C\u63D0\u5347\u7CFB\u7EDF\u7684\u6027\u80FD\u3001\u7A33\u5B9A\u6027\u548C\u8D44\u6E90\u5229\u7528\u6548\u7387\u3002 +sql.ContextUseShareMem.suggest = \u5F53\u524D\u663E\u793A\u7684\u662F TOP 10 \u4E0A\u4E0B\u6587\u4F7F\u7528\u5171\u4EAB\u5185\u5B58\u7684\u60C5\u51B5\u3002\u5EFA\u8BAE\u91CD\u70B9\u5206\u6790\u90A3\u4E9B\u5360\u7528\u5171\u4EAB\u5185\u5B58\u8F83\u5927\u7684\u4E0A\u4E0B\u6587\uFF0C\u4EE5\u8BC6\u522B\u6F5C\u5728\u7684\u8D44\u6E90\u5360\u7528\u5F02\u5E38\u3002\u901A\u8FC7\u6DF1\u5165\u5206\u6790\u8FD9\u4E9B\u4E0A\u4E0B\u6587\u7684\u5171\u4EAB\u5185\u5B58\u4F7F\u7528\u6A21\u5F0F\uFF0C\u53EF\u4EE5\u53D1\u73B0\u662F\u5426\u5B58\u5728\u4E0D\u5408\u7406\u7684\u5185\u5B58\u5206\u914D\u6216\u8D44\u6E90\u7ADE\u4E89\uFF0C\u4ECE\u800C\u4F18\u5316\u5185\u5B58\u4F7F\u7528\u6548\u7387\u3002\u8FDB\u4E00\u6B65\u7684\u4F18\u5316\u63AA\u65BD\u53EF\u5E2E\u52A9\u51CF\u8F7B\u5171\u4EAB\u5185\u5B58\u8D1F\u62C5\uFF0C\u63D0\u5347\u7CFB\u7EDF\u7684\u6027\u80FD\u548C\u54CD\u5E94\u901F\u5EA6\u3002 +sql.ContextUseShareMem.suggest.normal = \u5F53\u524D\u663E\u793A\u7684\u662F TOP 10 \u4E0A\u4E0B\u6587\u4F7F\u7528\u5171\u4EAB\u5185\u5B58\u7684\u60C5\u51B5\u3002\u5EFA\u8BAE\u91CD\u70B9\u5206\u6790\u90A3\u4E9B\u5360\u7528\u5171\u4EAB\u5185\u5B58\u8F83\u5927\u7684\u4E0A\u4E0B\u6587\uFF0C\u4EE5\u8BC6\u522B\u6F5C\u5728\u7684\u8D44\u6E90\u5360\u7528\u5F02\u5E38\u3002\u901A\u8FC7\u6DF1\u5165\u5206\u6790\u8FD9\u4E9B\u4E0A\u4E0B\u6587\u7684\u5171\u4EAB\u5185\u5B58\u4F7F\u7528\u6A21\u5F0F\uFF0C\u53EF\u4EE5\u53D1\u73B0\u662F\u5426\u5B58\u5728\u4E0D\u5408\u7406\u7684\u5185\u5B58\u5206\u914D\u6216\u8D44\u6E90\u7ADE\u4E89\uFF0C\u4ECE\u800C\u4F18\u5316\u5185\u5B58\u4F7F\u7528\u6548\u7387\u3002\u8FDB\u4E00\u6B65\u7684\u4F18\u5316\u63AA\u65BD\u53EF\u5E2E\u52A9\u51CF\u8F7B\u5171\u4EAB\u5185\u5B58\u8D1F\u62C5\uFF0C\u63D0\u5347\u7CFB\u7EDF\u7684\u6027\u80FD\u548C\u54CD\u5E94\u901F\u5EA6\u3002 +sql.ContextUseShareMem.suggest.high = \u5F53\u524D\u663E\u793A\u7684\u662F TOP 10 \u4E0A\u4E0B\u6587\u4F7F\u7528\u5171\u4EAB\u5185\u5B58\u7684\u60C5\u51B5\u3002\u5EFA\u8BAE\u91CD\u70B9\u5206\u6790\u90A3\u4E9B\u5360\u7528\u5171\u4EAB\u5185\u5B58\u8F83\u5927\u7684\u4E0A\u4E0B\u6587\uFF0C\u4EE5\u8BC6\u522B\u6F5C\u5728\u7684\u8D44\u6E90\u5360\u7528\u5F02\u5E38\u3002\u901A\u8FC7\u6DF1\u5165\u5206\u6790\u8FD9\u4E9B\u4E0A\u4E0B\u6587\u7684\u5171\u4EAB\u5185\u5B58\u4F7F\u7528\u6A21\u5F0F\uFF0C\u53EF\u4EE5\u53D1\u73B0\u662F\u5426\u5B58\u5728\u4E0D\u5408\u7406\u7684\u5185\u5B58\u5206\u914D\u6216\u8D44\u6E90\u7ADE\u4E89\uFF0C\u4ECE\u800C\u4F18\u5316\u5185\u5B58\u4F7F\u7528\u6548\u7387\u3002\u8FDB\u4E00\u6B65\u7684\u4F18\u5316\u63AA\u65BD\u53EF\u5E2E\u52A9\u51CF\u8F7B\u5171\u4EAB\u5185\u5B58\u8D1F\u62C5\uFF0C\u63D0\u5347\u7CFB\u7EDF\u7684\u6027\u80FD\u548C\u54CD\u5E94\u901F\u5EA6\u3002 +ResultType.MemoryAccumulation = \u5171\u4EAB\u5185\u5B58\u5185\u5B58\u5806\u79EF +MemoryAccumulation.tip = \u5F53\u524D\u663E\u793A\u7684\u662F\u4F7F\u7528\u5171\u4EAB\u5185\u5B58\u7684\u524D 10 \u4E2A\u4E0A\u4E0B\u6587\u7684\u5185\u5B58\u7533\u8BF7\u7684\u8BE6\u7EC6\u4FE1\u606F\u3002\u5EFA\u8BAE\u91CD\u70B9\u5206\u6790\u90A3\u4E9B\u5185\u5B58\u7533\u8BF7\u8F83\u5927\u7684\u4E0A\u4E0B\u6587\uFF0C\u4EE5\u8BC6\u522B\u662F\u5426\u5B58\u5728\u5185\u5B58\u6CC4\u6F0F\u6216\u672A\u91CA\u653E\u7684\u60C5\u51B5\u3002\u901A\u8FC7\u6DF1\u5165\u5206\u6790\u4EE3\u7801\uFF0C\u53EF\u4EE5\u67E5\u660E\u5185\u5B58\u5806\u79EF\u7684\u6839\u672C\u539F\u56E0\uFF0C\u4ECE\u800C\u4F18\u5316\u4EE3\u7801\uFF0C\u63D0\u5347\u7CFB\u7EDF\u7684\u6574\u4F53\u6027\u80FD\u3002 +MemoryAccumulationTable.name = \u4E0A\u4E0B\u6587\u7533\u8BF7\u5185\u5B58\u7684\u8BE6\u7EC6\u4FE1\u606F +MemoryAccumulationTable.column.contextname = \u4E0A\u4E0B\u6587\u540D\u79F0 +MemoryAccumulationTable.column.file = \u7533\u8BF7\u5185\u5B58\u6240\u5728\u6587\u4EF6\u7684\u6587\u4EF6\u540D +MemoryAccumulationTable.column.line = \u7533\u8BF7\u5185\u5B58\u6240\u5728\u6587\u4EF6\u7684\u4EE3\u7801\u884C\u53F7 +MemoryAccumulationTable.column.size = \u7533\u8BF7\u7684\u5185\u5B58\u5927\u5C0F +sql.MemoryAccumulation.title = \u4E0A\u4E0B\u6587\u7533\u8BF7\u5185\u5B58\u7684\u8BE6\u7EC6\u4FE1\u606F +sql.MemoryAccumulation.title.normal = \u4E0A\u4E0B\u6587\u7533\u8BF7\u5185\u5B58\u7684\u8BE6\u7EC6\u4FE1\u606F +sql.MemoryAccumulation.title.high = \u4E0A\u4E0B\u6587\u7533\u8BF7\u5185\u5B58\u7684\u8BE6\u7EC6\u4FE1\u606F +sql.MemoryAccumulation.detail = \u8BE5\u8BCA\u65AD\u9879\u901A\u8FC7\u67E5\u8BE2\u4E0A\u4E0B\u6587\u4F7F\u7528\u5171\u4EAB\u5185\u5B58\u7684\u8BE6\u7EC6\u4FE1\u606F\uFF0C\u6DB5\u76D6\u6BCF\u4E00\u5904\u5185\u5B58\u7533\u8BF7\u7684\u6587\u4EF6\u3001\u884C\u53F7\u53CA\u5176\u5927\u5C0F\uFF08\u5BF9\u4E8E\u540C\u4E00\u6587\u4EF6\u548C\u884C\u53F7\u7684\u5185\u5B58\u7533\u8BF7\uFF0C\u5927\u5C0F\u4F1A\u8FDB\u884C\u7D2F\u52A0\uFF09\u3002\u901A\u8FC7\u5206\u6790\u8FD9\u4E9B\u8BE6\u7EC6\u4FE1\u606F\uFF0C\u53EF\u4EE5\u6709\u6548\u8BC6\u522B\u4EE3\u7801\u4E2D\u662F\u5426\u5B58\u5728\u672A\u91CA\u653E\u5185\u5B58\u5BFC\u81F4\u7684\u5185\u5B58\u5806\u79EF\u95EE\u9898\uFF0C\u4ECE\u800C\u5E2E\u52A9\u5F00\u53D1\u4EBA\u5458\u53D1\u73B0\u6F5C\u5728\u7684\u5185\u5B58\u6CC4\u6F0F\u98CE\u9669\uFF0C\u4F18\u5316\u5185\u5B58\u7BA1\u7406\uFF0C\u63D0\u5347\u7CFB\u7EDF\u7A33\u5B9A\u6027\u548C\u6027\u80FD\u3002\n \u6CE8\uFF1A\u8BE5\u8BCA\u65AD\u9879\u4ECEopenGauss\u89C6\u56FE\u4E2D\u83B7\u53D6\u7684\u6570\u636E\uFF0C\u4E0D\u652F\u6301release\u7248\u672C\u5C0F\u578B\u5316\u573A\u666F\u3002\u4E14\u5FC5\u987B\u5177\u6709sysadmin\u6743\u9650\u6216\u8005monitor admin\u6743\u9650\u3002 +sql.MemoryAccumulation.suggest = \u5F53\u524D\u663E\u793A\u7684\u662F\u4F7F\u7528\u5171\u4EAB\u5185\u5B58\u7684\u524D 10 \u4E2A\u4E0A\u4E0B\u6587\u7684\u5185\u5B58\u7533\u8BF7\u7684\u8BE6\u7EC6\u4FE1\u606F\u3002\u5EFA\u8BAE\u91CD\u70B9\u5206\u6790\u90A3\u4E9B\u5185\u5B58\u7533\u8BF7\u8F83\u5927\u7684\u4E0A\u4E0B\u6587\uFF0C\u4EE5\u8BC6\u522B\u662F\u5426\u5B58\u5728\u5185\u5B58\u6CC4\u6F0F\u6216\u672A\u91CA\u653E\u7684\u60C5\u51B5\u3002\u901A\u8FC7\u6DF1\u5165\u5206\u6790\u4EE3\u7801\uFF0C\u53EF\u4EE5\u67E5\u660E\u5185\u5B58\u5806\u79EF\u7684\u6839\u672C\u539F\u56E0\uFF0C\u4ECE\u800C\u4F18\u5316\u4EE3\u7801\uFF0C\u63D0\u5347\u7CFB\u7EDF\u7684\u6574\u4F53\u6027\u80FD\u3002 +sql.MemoryAccumulation.suggest.normal = \u5F53\u524D\u663E\u793A\u7684\u662F\u4F7F\u7528\u5171\u4EAB\u5185\u5B58\u7684\u524D 10 \u4E2A\u4E0A\u4E0B\u6587\u7684\u5185\u5B58\u7533\u8BF7\u7684\u8BE6\u7EC6\u4FE1\u606F\u3002\u5EFA\u8BAE\u91CD\u70B9\u5206\u6790\u90A3\u4E9B\u5185\u5B58\u7533\u8BF7\u8F83\u5927\u7684\u4E0A\u4E0B\u6587\uFF0C\u4EE5\u8BC6\u522B\u662F\u5426\u5B58\u5728\u5185\u5B58\u6CC4\u6F0F\u6216\u672A\u91CA\u653E\u7684\u60C5\u51B5\u3002\u901A\u8FC7\u6DF1\u5165\u5206\u6790\u4EE3\u7801\uFF0C\u53EF\u4EE5\u67E5\u660E\u5185\u5B58\u5806\u79EF\u7684\u6839\u672C\u539F\u56E0\uFF0C\u4ECE\u800C\u4F18\u5316\u4EE3\u7801\uFF0C\u63D0\u5347\u7CFB\u7EDF\u7684\u6574\u4F53\u6027\u80FD\u3002 +sql.MemoryAccumulation.suggest.high = \u5F53\u524D\u663E\u793A\u7684\u662F\u4F7F\u7528\u5171\u4EAB\u5185\u5B58\u7684\u524D 10 \u4E2A\u4E0A\u4E0B\u6587\u7684\u5185\u5B58\u7533\u8BF7\u7684\u8BE6\u7EC6\u4FE1\u606F\u3002\u5EFA\u8BAE\u91CD\u70B9\u5206\u6790\u90A3\u4E9B\u5185\u5B58\u7533\u8BF7\u8F83\u5927\u7684\u4E0A\u4E0B\u6587\uFF0C\u4EE5\u8BC6\u522B\u662F\u5426\u5B58\u5728\u5185\u5B58\u6CC4\u6F0F\u6216\u672A\u91CA\u653E\u7684\u60C5\u51B5\u3002\u901A\u8FC7\u6DF1\u5165\u5206\u6790\u4EE3\u7801\uFF0C\u53EF\u4EE5\u67E5\u660E\u5185\u5B58\u5806\u79EF\u7684\u6839\u672C\u539F\u56E0\uFF0C\u4ECE\u800C\u4F18\u5316\u4EE3\u7801\uFF0C\u63D0\u5347\u7CFB\u7EDF\u7684\u6574\u4F53\u6027\u80FD\u3002 + history.AspAnalysis.title=\u6570\u636E\u5E93\u8FDB\u7A0BCPU\u5E73\u5747\u4F7F\u7528\u7387 history.AspAnalysis.title.normal=\u6570\u636E\u5E93\u8FDB\u7A0BCPU\u6CA1\u51FA\u73B0\u79D2\u7EA7\u6296\u52A8 diff --git a/plugins/observability-sql-diagnosis/src/main/resources/sqlTreeNode.txt b/plugins/observability-sql-diagnosis/src/main/resources/sqlTreeNode.txt index d40ba72f2..dfbb64c2b 100644 --- a/plugins/observability-sql-diagnosis/src/main/resources/sqlTreeNode.txt +++ b/plugins/observability-sql-diagnosis/src/main/resources/sqlTreeNode.txt @@ -45,3 +45,10 @@ --ParamTuning CENTER ---OsParam CENTER ---DatabaseParam CENTER +--DbMemAnalysis DIAGNOSIS +---DbDynamicMemory DIAGNOSIS +----SqlUseDynamicMem DISPLAY +----DbMemLeak DISPLAY +---DbShareMemory DIAGNOSIS +----ContextUseShareMem DISPLAY +-----MemoryAccumulation DISPLAY -- Gitee