增加监控采集频率配置项 #64

nacos-group · Jun 30, 2024 · 4891f49 · 4891f49
1 parent 0c957d7
commit 4891f49
Show file tree

Hide file tree

Showing 7 changed files with 88 additions and 29 deletions.
diff --git a/README.md b/README.md
@@ -146,7 +146,8 @@ rnacos
 |RNACOS_INIT_ADMIN_USERNAME|初始化管理员用户名，只在主节点第一次启动时生效|admin|rnacos|0.5.11|
 |RNACOS_INIT_ADMIN_PASSWORD|初始化管理员密码，只在主节点第一次启动时生效|admin|rnacos123456|0.5.11|
 |RNACOS_ENABLE_METRICS|是否开启监控指标功能|true|true|0.5.13|
-|RNACOS_METRICS_LOG_INTERVAL_SECOND|监控指标采集打印到日志的间隔,单位秒,最小间隔为5秒|30|10|0.5.13|
+|RNACOS_METRICS_COLLECT_INTERVAL_SECOND|监控指标采集指标间隔,单位秒,最小间隔为1秒,不能小于RNACOS_METRICS_LOG_INTERVAL_SECOND|15|5|0.5.14|
+|RNACOS_METRICS_LOG_INTERVAL_SECOND|监控指标采集打印到日志的间隔,单位秒,最小间隔为5秒|60|30|0.5.13|
 
 
 启动配置方式可以参考： [运行参数说明](https://r-nacos.github.io/docs/notes/env_config/)
@@ -347,7 +348,6 @@ nacos_rust_client = "0.3.0"
 访问认证：
 
 1. 有提供获取认证token的接口
-2. 实际请求暂不支持认证，都算认证通过。
 
 配置中心：
 

diff --git a/doc/conf/.env.example b/doc/conf/.env.example
@@ -65,9 +65,12 @@ RNACOS_INIT_ADMIN_USERNAME=admin
 # 初始化管理员密码在主节点第一次启动时生效，默认值：admin
 RNACOS_INIT_ADMIN_PASSWORD=admin
 
-#是否开启监控指标功能
+#是否开启监控指标功能,开启后支持prometheus metrics exporter http://127.0.0.1:8848/metrics
 RNACOS_ENABLE_METRICS=true
 
+#监控指标采集指标间隔,单位秒,最小间隔为1秒,不能小于RNACOS_METRICS_LOG_INTERVAL_SECOND
+RNACOS_METRICS_COLLECT_INTERVAL_SECOND=15
+
 #监控指标采集打印到日志的间隔,单位秒,最小间隔为5秒
-RNACOS_METRICS_LOG_INTERVAL_SECOND=30
+RNACOS_METRICS_LOG_INTERVAL_SECOND=60
 
diff --git a/src/common/mod.rs b/src/common/mod.rs
@@ -76,6 +76,7 @@ pub struct AppSysConfig {
     pub init_admin_username: String,
     pub init_admin_password: String,
     pub metrics_enable: bool,
+    pub metrics_collect_interval_second: u64,
     pub metrics_log_interval_second: u64,
 }
 
@@ -160,13 +161,24 @@ impl AppSysConfig {
             .unwrap_or("true".to_owned())
             .parse()
             .unwrap_or(true);
+        let mut metrics_collect_interval_second =
+            std::env::var("RNACOS_METRICS_COLLECT_INTERVAL_SECOND")
+                .unwrap_or("15".to_owned())
+                .parse()
+                .unwrap_or(15);
+        if metrics_collect_interval_second < 1 {
+            metrics_collect_interval_second = 1;
+        }
         let mut metrics_log_interval_second = std::env::var("RNACOS_METRICS_LOG_INTERVAL_SECOND")
-            .unwrap_or("30".to_owned())
+            .unwrap_or("60".to_owned())
             .parse()
-            .unwrap_or(30);
+            .unwrap_or(60);
         if metrics_log_interval_second < 5 {
             metrics_log_interval_second = 5;
         }
+        if metrics_log_interval_second < metrics_collect_interval_second {
+            metrics_collect_interval_second = metrics_log_interval_second;
+        }
         Self {
             config_db_dir,
             config_db_file,
@@ -191,6 +203,7 @@ impl AppSysConfig {
             init_admin_username,
             init_admin_password,
             metrics_enable,
+            metrics_collect_interval_second,
             metrics_log_interval_second,
         }
     }

diff --git a/src/metrics/core.rs b/src/metrics/core.rs
@@ -32,9 +32,11 @@ pub struct MetricsManager {
     system: System,
     current_process_id: u32,
     start_time_millis: u64,
-    //last_load_time: u64,
     total_memory: f64,
+    collect_interval: u64,
     log_interval: u64,
+    last_collect_time: u64,
+    last_log_time: u64,
     metrics_enable: bool,
 }
 
@@ -65,9 +67,11 @@ impl MetricsManager {
             system,
             current_process_id,
             start_time_millis,
-            //last_load_time: 0,
             total_memory,
-            log_interval: 30,
+            log_interval: 60,
+            collect_interval: 15,
+            last_collect_time: 0,
+            last_log_time: 0,
             metrics_enable: true,
         }
     }
@@ -162,12 +166,18 @@ impl MetricsManager {
         }
     }
 
-    fn print_metrics(&self) {
+    fn print_metrics(&mut self) {
+        let now = now_millis();
+        if now - self.last_log_time < (self.log_interval - 1) * 1000 {
+            return;
+        }
         //log::info!("-------------- log metrics start --------------");
+        self.print_sys_metrics();
         self.gauge_manager.print_metrics();
         self.counter_manager.print_metrics();
         self.histogram_manager.print_metrics();
         self.summary_manager.print_metrics();
+        self.last_log_time = now;
     }
 
     fn load_sys_metrics(&mut self) {
@@ -178,7 +188,7 @@ impl MetricsManager {
             let vms = process.virtual_memory() as f64 / (1024.0 * 1024.0);
             let rss_usage = rss / self.total_memory * 100.0;
             let running_seconds = (now_millis() - self.start_time_millis) / 1000;
-            log::info!("[metrics_system]|already running seconds: {}s|cpu_usage: {:.2}%|rss_usage: {:.2}%|rss: {:.2}M|vms: {:.2}M|total_memory: {:.2}M|",running_seconds,&cpu_usage,&rss_usage,&rss,&vms,&self.total_memory);
+            //log::info!("[metrics_system]|already running seconds: {}s|cpu_usage: {:.2}%|rss_usage: {:.2}%|rss: {:.2}M|vms: {:.2}M|total_memory: {:.2}M|",running_seconds,&cpu_usage,&rss_usage,&rss,&vms,&self.total_memory);
             self.gauge_manager
                 .set(MetricsKey::ProcessStartTimeSeconds, running_seconds as f64);
             self.gauge_manager.set(MetricsKey::AppCpuUsage, cpu_usage);
@@ -187,6 +197,31 @@ impl MetricsManager {
             self.gauge_manager
                 .set(MetricsKey::AppMemoryUsage, rss_usage);
         }
+        self.last_collect_time = now_millis();
+    }
+
+    fn print_sys_metrics(&self) {
+        let cpu_usage = self
+            .gauge_manager
+            .value(&MetricsKey::AppCpuUsage)
+            .unwrap_or_default();
+        let rss = self
+            .gauge_manager
+            .value(&MetricsKey::AppRssMemory)
+            .unwrap_or_default();
+        let vms = self
+            .gauge_manager
+            .value(&MetricsKey::AppVmsMemory)
+            .unwrap_or_default();
+        let rss_usage = self
+            .gauge_manager
+            .value(&MetricsKey::AppMemoryUsage)
+            .unwrap_or_default();
+        let running_seconds = self
+            .gauge_manager
+            .value(&MetricsKey::ProcessStartTimeSeconds)
+            .unwrap_or_default();
+        log::info!("[metrics_system]|already running seconds: {}s|cpu_usage: {:.2}%|rss_usage: {:.2}%|rss: {:.2}M|vms: {:.2}M|total_memory: {:.2}M|",running_seconds,&cpu_usage,&rss_usage,&rss,&vms,&self.total_memory);
     }
 
     fn load_metrics(&mut self, ctx: &mut Context<Self>) {
@@ -206,7 +241,7 @@ impl MetricsManager {
             .spawn(ctx);
     }
     fn hb(&mut self, ctx: &mut Context<Self>) {
-        ctx.run_later(Duration::from_secs(self.log_interval), |act, ctx| {
+        ctx.run_later(Duration::from_secs(self.collect_interval), |act, ctx| {
             act.load_metrics(ctx);
         });
     }
@@ -244,6 +279,7 @@ impl Inject for MetricsManager {
         let sys_config: Option<Arc<AppSysConfig>> = factory_data.get_bean();
         if let Some(sys_config) = sys_config {
             self.metrics_enable = sys_config.metrics_enable;
+            self.collect_interval = sys_config.metrics_collect_interval_second;
             self.log_interval = sys_config.metrics_log_interval_second;
             if self.metrics_enable {
                 log::info!("metrics enable! log_interval: {}s", self.log_interval);

diff --git a/src/metrics/gauge.rs b/src/metrics/gauge.rs
@@ -36,6 +36,14 @@ impl GaugeManager {
         }
     }
 
+    pub fn value(&self, key: &Key) -> Option<f64> {
+        if let Some(item) = self.date_map.get(&key) {
+            Some(item.0.to_owned())
+        } else {
+            None
+        }
+    }
+
     pub fn print_metrics(&self) {
         //log::info!("-------------- METRICS GAUGE --------------");
         for key in ORDER_ALL_KEYS.iter() {

diff --git a/src/metrics/metrics_key.rs b/src/metrics/metrics_key.rs
@@ -236,10 +236,14 @@ impl MetricsKey {
             MetricsKey::GrpcConnResponseTimeoutSetItemSize => {
                 "Grpc conn response timeout set item size"
             }
-            MetricsKey::GrpcRequestHandleRtHistogram => "Grpc request handle rt histogram,unit is ms",
+            MetricsKey::GrpcRequestHandleRtHistogram => {
+                "Grpc request handle rt histogram,unit is ms"
+            }
             MetricsKey::GrpcRequestHandleRtSummary => "Grpc request handle rt summary, unit is ms",
             MetricsKey::GrpcRequestTotalCount => "Grpc request total count",
-            MetricsKey::HttpRequestHandleRtHistogram => "Http request handle rt histogram,unit is ms",
+            MetricsKey::HttpRequestHandleRtHistogram => {
+                "Http request handle rt histogram,unit is ms"
+            }
             MetricsKey::HttpRequestHandleRtSummary => "Http request handle rt summary,unit is ms",
             MetricsKey::HttpRequestTotalCount => "Http request total count",
             //default describe

diff --git a/src/metrics/model.rs b/src/metrics/model.rs
@@ -197,25 +197,23 @@ impl HistogramValue {
         let mut p_sum_count = 0u64;
         let mut bound = 0f64;
         let mut sum_count = 0u64;
-        let mut i=0;
-        while i< buckets.len() {
-            let (b,v) = buckets.get(i).unwrap();
+        let mut i = 0;
+        while i < buckets.len() {
+            let (b, v) = buckets.get(i).unwrap();
             bound = b.to_owned();
             sum_count = v.to_owned();
             if q_value < sum_count {
                 return p_bound
                     + ((q_value - p_sum_count) as f64 / (sum_count - p_sum_count) as f64)
-                    * (bound - p_bound)
-            }
-            else if q_value == sum_count {
+                        * (bound - p_bound);
+            } else if q_value == sum_count {
                 return b.to_owned();
-            }
-            else {
-                if self.count==sum_count {
+            } else {
+                if self.count == sum_count {
                     return bound;
                 }
-                i+=1;
-                if i< buckets.len() {
+                i += 1;
+                if i < buckets.len() {
                     p_bound = bound;
                     p_sum_count = sum_count;
                 }
@@ -226,10 +224,7 @@ impl HistogramValue {
         } else {
             bound
         };
-        bound
-            + ((q_value - sum_count) as f64
-            / (self.count - sum_count) as f64)
-            * interval_bound
+        bound + ((q_value - sum_count) as f64 / (self.count - sum_count) as f64) * interval_bound
     }
 
     pub fn record(&mut self, sample: f64) {