refactor: 优化日志输出

Author: davidfantasy

src/event.rs

@@ -70,7 +70,7 @@ pub fn handle_process_event(sender: Sender<ProcessEvent>, rx: Receiver<ProcessEv
         match received.event_type {
             EventType::Running => {
                 info!(
-                    "The {} service started with pid: {}",
+                    "[{}] started with pid: {}",
                     received.service_name,
                     received
                         .pid
@@ -85,7 +85,7 @@ pub fn handle_process_event(sender: Sender<ProcessEvent>, rx: Receiver<ProcessEv
                     .map_or_else(|| "unknown".to_string(), |pid| pid.to_string());
                 let msg = received.data.or(Some("unknown".to_string())).unwrap();
                 warn!(
-                    "The {} service (pid: {}) has exited:{}",
+                    "[{}] (pid: {}) has exited:{}",
                     received.service_name, pid, msg
                 );
             }
@@ -94,7 +94,7 @@ pub fn handle_process_event(sender: Sender<ProcessEvent>, rx: Receiver<ProcessEv
                     .pid
                     .map_or_else(|| "unknown".to_string(), |pid| pid.to_string());
                 info!(
-                    "The {} service (pid: {}) has be stopped,will stop health watch",
+                    "[{}] (pid: {}) has be stopped,will stop health watch",
                     received.service_name, pid,
                 );
                 health::stop_watch(received.service_name)
@@ -103,7 +103,7 @@ pub fn handle_process_event(sender: Sender<ProcessEvent>, rx: Receiver<ProcessEv
                 process::status::change_proc_health_status(&received.service_name, false)
                     .unwrap_or_else(|err| {
                         warn!(
-                            "change process {} health status failed: {}",
+                            "change [{}] health status failed: {}",
                             &received.service_name, err
                         );
                     });
@@ -112,7 +112,7 @@ pub fn handle_process_event(sender: Sender<ProcessEvent>, rx: Receiver<ProcessEv
                 process::status::change_proc_health_status(&received.service_name, true)
                     .unwrap_or_else(|err| {
                         warn!(
-                            "change process {} health status failed: {}",
+                            "change [{}] health status failed: {}",
                             &received.service_name, err
                         );
                     });

src/health.rs

@@ -4,7 +4,7 @@ use crate::{
     process,
 };
 use lazy_static::lazy_static;
-use log::{debug, info, warn};
+use log::{info, warn};
 use std::{collections::HashMap, sync::RwLock, thread, time::Duration};
 
 lazy_static! {
@@ -14,7 +14,7 @@ lazy_static! {
 pub fn start_watch(service_name: String, config: Option<HealthCheckConfig>) {
     let health_cfg = config.clone(); // to avoid borrow count
     if health_cfg.is_none() || !health_cfg.unwrap().enable {
-        info!("service {} is not enabled to health check", &service_name);
+        info!("[{}] is not enabled to health check", &service_name);
         return;
     }
     if is_watching(&service_name) {
@@ -28,10 +28,7 @@ pub fn start_watch(service_name: String, config: Option<HealthCheckConfig>) {
 pub fn stop_watch(service_name: String) {
     let mut status = SERVICES_HEALTH_STATUS.write().unwrap();
     if !status.contains_key(&service_name) {
-        warn!(
-            "The service {} is not being watched, ignore stop",
-            &service_name
-        );
+        warn!("[{}] is not being watched, ignore stop", &service_name);
         return;
     }
     status.remove(&service_name);
@@ -54,11 +51,11 @@ fn do_watch_health(service_name: String, config: HealthCheckConfig) {
     if !is_watching(&service_name) {
         return;
     }
-    info!("service {} has enabled health checks", &service_name);
+    info!("[{}] has enabled health checks", &service_name);
     loop {
         if !is_watching(&service_name) {
             info!(
-                "service {} is not being watched, stop health check",
+                "[{}] is not being watched, stop health check",
                 &service_name
             );
             break;
@@ -73,9 +70,9 @@ fn do_watch_health(service_name: String, config: HealthCheckConfig) {
             let fail_times = incr_fail_times(&service_name);
             let restart: bool = fail_times > config.max_failures;
             if restart {
-                warn!("health check failure count for service {} has exceeded the threshold, preparing to restart it", &service_name);
+                warn!("health check failure count for [{}] has exceeded the threshold, preparing to restart it", &service_name);
                 process::manager::restart_service(&service_name).unwrap_or_else(|err| {
-                    warn!("restart service {} failed: {}", &service_name, err);
+                    warn!("restart [{}] failed: {}", &service_name, err);
                 });
                 check_interval += config.check_delay.unwrap_or(0);
             }

src/process/manager.rs

@@ -30,7 +30,7 @@ pub fn start_services(services: Vec<String>) -> Result<()> {
         if dep_ok {
             start_service(name)?;
         } else {
-            info!("service [{}] has dependencies, add to pending list", name);
+            info!("[{}] has dependencies, add to pending list", name);
             let deps = service_info.unwrap().config.depends_on.clone().unwrap();
             pending::add_pending_service(name, deps)
         }
@@ -47,7 +47,7 @@ pub fn start_service(service_name: &str) -> Result<()> {
         let pid_val = pid.unwrap();
         if status::is_running_by_pid(pid_val) {
             info!(
-                "service [{}] is already running with pid {}!",
+                "[{}] is already running with pid {}!",
                 service_name, pid_val
             );
             event::send_process_event(service_name, EventType::Running, None, pid);
@@ -56,7 +56,7 @@ pub fn start_service(service_name: &str) -> Result<()> {
     }
     thread::spawn(move || {
         if let Err(err) = spawn_proc(Arc::clone(&conf)) {
-            error!("service [{}] exited with error: {}", svc_name, err);
+            error!("[{}] exited with error: {}", svc_name, err);
         }
     });
     Ok(())
@@ -76,7 +76,7 @@ pub fn stop_service(service_name: &str) -> Result<()> {
     let proc_runtime = status::find_readonly_proc_runtime(service_name)?;
     let pid = proc_runtime.pid;
     if pid.is_none() {
-        info!("service [{}]  is not running!", service_name);
+        info!("[{}]  is not running!", service_name);
         return Ok(());
     }
     let pid_val = pid.unwrap();
@@ -87,12 +87,12 @@ pub fn stop_service(service_name: &str) -> Result<()> {
     })?;
     if !is_running {
         info!(
-            "ignore stop command, service [{}]  is not running, pid: {}!",
+            "ignore stop command, [{}]  is not running, pid: {}!",
             service_name, pid_val
         );
         return Ok(());
     }
-    info!("service [{}] (pid: {}) is stopping", service_name, pid_val);
+    info!("[{}] (pid: {}) is stopping", service_name, pid_val);
     //首先尝试通过信号量的方式让进程自己退出
     if let Err(err) = terminate_process(pid_val) {
         warn!("signal {} (pid: {}) failed: {}", service_name, pid_val, err);
@@ -105,7 +105,7 @@ pub fn stop_service(service_name: &str) -> Result<()> {
     }
     //如果超过规定时间进程没有退出，则强制杀掉进程
     if is_running {
-        info!("service [{}] (pid: {}) is still running within the specified time after sending the interrupt signal, and is ready to be killed", service_name, pid_val);
+        info!("[{}] (pid: {}) is still running within the specified time after sending the interrupt signal, and is ready to be killed", service_name, pid_val);
         kill_process(pid_val)?;
     }
     Ok(())
@@ -151,7 +151,7 @@ fn spawn_proc(conf: Arc<ServiceConfig>) -> Result<()> {
     }
     if command.starts_with(".") {}
     before_exec(&mut cmd)?;
-    debug!("execute service [{}] start command:{}", svc_name, command);
+    debug!("execute [{}] start command:{}", svc_name, command);
     let child = cmd.spawn().map_err(|e| format!("{}", e));
     match child {
         Ok(mut child_proc) => {