diff --git a/src/process1/Cargo.toml b/src/process1/Cargo.toml
index 01451231f7b2e3fa9becf1cd2e1cfe6e5c4b10fc..c4d92136d91327eeafcb67378c6b4dedccea5e96 100644
--- a/src/process1/Cargo.toml
+++ b/src/process1/Cargo.toml
@@ -5,6 +5,9 @@ authors = ["overweight <hexiaowen@huawei.com>"]
 edition = "2018"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+[[bin]]
+name = "process1"
+path = "src/bin/process1.rs"
 
 [lib]
 path = "src/lib.rs"
@@ -12,3 +15,6 @@ path = "src/lib.rs"
 [dependencies]
 dynamic_reload = "0.4.0"
 walkdir = "2"
+log = "0.4"
+log4rs = "1.0"
+#log4rs = { version="1.0", optional=true}
diff --git a/src/process1/src/bin/process1.rs b/src/process1/src/bin/process1.rs
new file mode 100644
index 0000000000000000000000000000000000000000..a73fc23a0788c711c2cf9bb7d42ec0230b898a4e
--- /dev/null
+++ b/src/process1/src/bin/process1.rs
@@ -0,0 +1,5 @@
+mod util;
+fn main() {
+    util::logging::init_log_with_console("process1", 0);
+    log::info!("process one test");
+}
diff --git a/src/process1/src/bin/util/logging/mod.rs b/src/process1/src/bin/util/logging/mod.rs
new file mode 100644
index 0000000000000000000000000000000000000000..a4c48ca5cc9f81bc0806215a4bb4c8bb79508019
--- /dev/null
+++ b/src/process1/src/bin/util/logging/mod.rs
@@ -0,0 +1,76 @@
+use std::path::Path;
+use log4rs::{
+    append::console::{ConsoleAppender, Target},
+    append::file::FileAppender,
+    config::{Appender,Config,Logger,Root},
+    encode::pattern::PatternEncoder,
+};
+use log::LevelFilter;
+/// Init logger whith config yaml file.
+///
+/// [`path`] the config file path
+/// example
+/// see docs.rs/log4rs/1.0.0/#examples
+///
+pub fn init_log_with_file<P>(path: P)
+where  //where 字句限定 P的类型
+    P: AsRef<Path>,
+{
+    log4rs::init_file(path,Default::default()).expect("logging init");
+}
+
+/// Init logger output the log to console.
+///
+/// [`app_name`] which app output the log
+/// log level set the output log level
+/// [0] Error
+/// [1] Warn
+/// [2] Info.
+/// [3] Debug
+/// [4]  Trace
+/// [others] Info
+///
+pub fn init_log_with_console(app_name:&str,log_level:u32){
+
+    let mut pattern = String::new();
+    pattern += "{d(%Y-%m-%d %H:%M:%S)} ";
+    pattern += "{h({l}):<5} ";
+    pattern += "{m}{n}";
+    let stdout = ConsoleAppender::builder().encoder(Box::new(PatternEncoder::new(&pattern))).target(Target::Stderr).build();
+    let logging_builder = Config::builder()
+        .appender(Appender::builder().build("console",  Box::new(stdout)));
+    let l_level;
+    match log_level {
+        0 => l_level = LevelFilter::Error,
+        1 => l_level = LevelFilter::Warn,
+        2 => l_level = LevelFilter::Info,
+        3 => l_level = LevelFilter::Debug,
+        4 => l_level = LevelFilter::Trace,
+        _ => l_level = LevelFilter::Info,
+    }
+
+    let config = match Some(app_name){
+        Some(a_p) => logging_builder.logger(Logger::builder().build(a_p, l_level)).build(Root::builder().appender("console").build(l_level)),
+        _ => logging_builder.build(Root::builder().appender("console").build(l_level)),
+    }.unwrap();
+    log4rs::init_config(config).unwrap();
+}
+
+
+#[cfg(test)]
+
+mod tests {
+    use super::*;
+    use log;
+    #[test]
+    fn test_init_log_with_console(){
+        init_log_with_console("test",4);
+        assert_eq!((),());
+        log::info!("test for logger info");
+        log::error!("test for logger error");
+        log::warn!("test for logger warn");
+        log::debug!("test for logger debug");
+        log::trace!("test for logger trace");
+    }
+
+}
diff --git a/src/process1/src/bin/util/mod.rs b/src/process1/src/bin/util/mod.rs
new file mode 100644
index 0000000000000000000000000000000000000000..cdb11a39d07140f986ed35e8479b021b6133114d
--- /dev/null
+++ b/src/process1/src/bin/util/mod.rs
@@ -0,0 +1 @@
+pub mod logging;
\ No newline at end of file
diff --git a/src/process1/src/plugin/mod.rs b/src/process1/src/plugin/mod.rs
index 9b5bde3c423c6b6a7ca3deed2b631253a4f194b6..41ed29266ae552f21bb3e95aa08f3278ac73b222 100644
--- a/src/process1/src/plugin/mod.rs
+++ b/src/process1/src/plugin/mod.rs
@@ -1,115 +1,128 @@
-
-use dynamic_reload;
-use std::sync::Arc;
-use std::time::Duration;
-use walkdir::{DirEntry,WalkDir};
-use std::path::Path;
-
-struct LibLoaders{
-    libs: Vec<Arc<dynamic_reload::Lib>>,
-}
-
-impl LibLoaders {
-    fn add_lib(&mut self, lib: &Arc<dynamic_reload::Lib>) {
-        self.libs.push(lib.clone());
-    }
-
-    fn unload_lib(&mut self, lib: &Arc<dynamic_reload::Lib>) {
-        for i in (0..self.libs.len()).rev() {
-            if &self.libs[i] == lib {
-                self.libs.swap_remove(i);
-            }
-        }
-    }
-    fn reload_lib(&mut self,lib:&Arc<dynamic_reload::Lib>){
-        Self::add_lib(self,lib);
-    }
-
-    fn reload_callback(&mut self, state:dynamic_reload::UpdateState, lib: Option<&Arc<dynamic_reload::Lib>>){
-        match state {
-            dynamic_reload::UpdateState::Before => Self::unload_lib(self,lib.unwrap()),
-            dynamic_reload::UpdateState::After => Self::reload_lib(self,lib.unwrap()),
-            dynamic_reload::UpdateState::ReloadFailed(_) =>println!("Reload plugin failed"),
-        }
-    }
-}
-
-
-pub struct Plugin<T> {
-    plugin_lists: Vec<Arc<T>>,
-    library_dir: String,
-    lib_loader: LibLoaders    
-}
-
-#[allow(dead_code)]
-impl <T>Plugin<T> {
-    fn new() -> Self {
-        Self{
-            plugin_lists: Vec::new(),
-            library_dir: String::new(),
-            lib_loader:  LibLoaders{libs:Vec::new()},
-
-        }
-    }
-
-    pub fn set_library_dir(&mut self,library_dir:&str){
-        self.library_dir.push_str(library_dir);
-    }
-
-    pub fn is_dynamic_lib(entry: &DirEntry) -> bool{
-        let file_type = entry.file_type();
-        let file_name = entry.file_name();
-        if file_type.is_file() && file_name.to_str().map(|s| s.ends_with(".so.*")).unwrap_or(false) {
-            true
-        } else {
-            false
-        }
-    }
-
-    pub fn load_lib(&mut self){
-        let file_exist = || {
-            if self.library_dir.is_empty() {
-                return false
-            }
-            if !Path::new(&self.library_dir).is_dir(){
-                return false
-            }
-            true
-        };
-        if !file_exist() {
-            return
-        }else{
-            let mut reload_handler = dynamic_reload::DynamicReload::new(Some(vec![self.library_dir.as_str()]), Some(self.library_dir.as_str()), dynamic_reload::Search::Default);
-            for entry in WalkDir::new(&self.library_dir)
-            .follow_links(true)
-            .into_iter()
-            .filter_entry(|e| Self::is_dynamic_lib(e)){
-                let entry = entry.unwrap();
-                let path = entry.path();
-                if path.is_dir(){
-                    continue;
-                }else{
-                    let file_name = path.file_name();
-                    match file_name {
-                        Some(v) => {
-                            let str_name = v.to_str().unwrap();
-                            match reload_handler.add_library(&str_name, dynamic_reload::PlatformName::Yes){
-                                Ok(lib) =>{
-                                    println!("loader dynamic lib in to lib_loader");
-                                    self.lib_loader.add_lib(&lib);
-                                }
-                                Err(e) =>{
-                                    println!("Unable to load dynamic lib, err {:?}", e);
-                                }
-                            }
-                        }
-                        None =>{
-                            println!("file name is None");
-                        }
-                    }
-                }
-                
-            }               
-        }
-    }
-}
+
+use dynamic_reload as dy_re;
+use std::sync::Arc;
+use walkdir::{DirEntry,WalkDir};
+use std::path::Path;
+use log::*;
+use super::manager::*;
+
+struct LibLoaders{
+    libs: Vec<Arc<dynamic_reload::Lib>>,
+}
+
+impl LibLoaders {
+    fn add_lib(&mut self, lib: &Arc<dy_re::Lib>) {
+        self.libs.push(lib.clone());
+    }
+
+    fn unload_lib(&mut self, lib: &Arc<dy_re::Lib>) {
+        for i in (0..self.libs.len()).rev() {
+            if &self.libs[i] == lib {
+                self.libs.swap_remove(i);
+            }
+        }
+    }
+    fn reload_lib(&mut self,lib: &Arc<dy_re::Lib>){
+        Self::add_lib(self,lib);
+    }
+
+    fn reload_callback(&mut self, state: dy_re::UpdateState, lib: Option<&Arc<dy_re::Lib>>){
+        match state {
+            dynamic_reload::UpdateState::Before => Self::unload_lib(self,lib.unwrap()),
+            dynamic_reload::UpdateState::After => Self::reload_lib(self,lib.unwrap()),
+            dynamic_reload::UpdateState::ReloadFailed(_) =>error!("Reload plugin failed"),
+        }
+    }
+}
+
+
+pub struct Plugin<T> {
+    plugin_lists: Vec<Arc<T>>,
+    library_dir: String,
+    lib_loader: LibLoaders
+}
+
+#[allow(dead_code)]
+impl <T: unit::UnitObj>Plugin<T> {
+    fn new() -> Self {
+        Self{
+            plugin_lists: Vec::new(),
+            library_dir: String::new(),
+            lib_loader:  LibLoaders{libs: Vec::new()},
+
+        }
+    }
+    pub fn add_plugin_to_list(&mut self,p: T){
+        self.plugin_lists.push(Arc::new(p));
+    }
+
+    pub fn set_library_dir(&mut self,library_dir: &str){
+        self.library_dir.push_str(library_dir);
+    }
+
+    pub fn is_dynamic_lib(entry: &DirEntry) -> bool{
+        let file_type = entry.file_type();
+        let file_name = entry.file_name();
+        if file_type.is_file() && file_name.to_str().map(|s| s.ends_with(".so.*")).unwrap_or(false) {
+            true
+        } else {
+            false
+        }
+    }
+
+    pub fn load_lib(&mut self){
+        let file_exist = || {
+            if self.library_dir.is_empty() {
+                return false
+            }
+            if !Path::new(&self.library_dir).is_dir(){
+                return false
+            }
+            true
+        };
+        if !file_exist() {
+            return
+        }else{
+            let mut reload_handler = dynamic_reload::DynamicReload::new(Some(vec![self.library_dir.as_str()]), Some(self.library_dir.as_str()), dynamic_reload::Search::Default);
+            for entry in WalkDir::new(&self.library_dir)
+            .follow_links(true)
+            .into_iter()
+            .filter_entry(|e| Self::is_dynamic_lib(e)){
+                let entry = entry.unwrap();
+                let path = entry.path();
+                if path.is_dir(){
+                    continue;
+                }else{
+                    let file_name = path.file_name();
+                    if let Some(v) = file_name {
+                        let str_name = v.to_str().unwrap();
+                        match reload_handler.add_library(&str_name, dynamic_reload::PlatformName::Yes){
+                            Ok(lib) =>{
+                                info!("loader dynamic lib in to lib_loader");
+                                self.lib_loader.add_lib(&lib);
+                            }
+                            Err(e) =>{
+                                error!("error loadingUnable to load dynamic lib, err {:?}", e);
+                            }
+                        }
+                    } else {
+                        warn!("loader dynamic lib file name is None");
+                    }
+                }
+            }
+        }
+    }
+}
+
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_plugin_load_library(){
+        let mut plugins: Plugin<super::unit::Unit> = Plugin::new();
+        plugins.load_lib();
+    }
+
+}