Logging updates

src/delegates.rs

@@ -34,7 +34,7 @@ pub struct CallInfo {
 }
 
 pub fn fire_handlers(ctx: Arc<ice_server::Context>, req: Request) -> Box<Future<Item = Response, Error = String>> {
-    let logger = logging::Logger::new("fire_handlers");
+    let logger = logging::Logger::new("delegates::fire_handlers");
 
     let mut target_req = glue::Request::new();
 

src/session_storage.rs

@@ -5,6 +5,8 @@ use std::sync::atomic;
 use uuid::Uuid;
 use time;
 
+use logging;
+
 pub struct SessionStorage {
     sessions: RwLock<BTreeMap<String, Arc<RwLock<Session>>>>,
     current_generation: atomic::AtomicUsize
@@ -53,6 +55,8 @@ impl SessionStorage {
     }
 
     pub fn gc(&self, timeout_ms: u64) {
+        let logger = logging::Logger::new("SessionStorage::gc");
+
         let mut to_remove: Vec<String> = Vec::new();
         let current_time = time::millis();
 
@@ -71,7 +75,7 @@ impl SessionStorage {
             return;
         }
 
-        println!("[SessionStorage] GC: Removing {} sessions", to_remove.len());
+        logger.log(logging::Message::Info(format!("Removing {} sessions", to_remove.len())));
 
         {
             let mut sessions = self.sessions.write().unwrap();

src/static_file.rs

@@ -12,6 +12,7 @@ use futures::Stream;
 use futures::sync::oneshot;
 
 use ice_server;
+use logging;
 
 pub struct WorkerControlMessage {
     path: String,
@@ -26,8 +27,10 @@ enum Metadata {
 }
 
 pub fn fetch(ctx: &ice_server::Context, p: &str, dir: &str) -> Box<Future<Item = Response, Error = String>> {
+    let logger = logging::Logger::new("static_file::fetch");
+
     if !p.starts_with("/") || p.contains("..") { // TODO: Is this really safe ?
-        println!("[static_file::fetch] Blocked: {}", p);
+        logger.log(logging::Message::Warning(format!("Blocked: {}", p)));
         return futures::future::err("Invalid path".to_string()).boxed();
     }
 
@@ -76,12 +79,20 @@ pub fn fetch_raw_unchecked(ctx: &ice_server::Context, mut resp: Response, p: &st
 }
 
 pub fn worker(remote_handle: tokio_core::reactor::Remote, control_rx: std::sync::mpsc::Receiver<WorkerControlMessage>) {
+    let mut warning_showed = false;
+    let logger = logging::Logger::new("static_file::worker");
+
     loop {
         let mut msg = control_rx.recv().unwrap();
         let remote_handle_cloned = remote_handle.clone();
         let data_tx = msg.data_tx.clone();
         let path = msg.path.clone();
 
+        if !warning_showed {
+            logger.log(logging::Message::Warning("Please use a reverse proxy to serve static files in production.".to_string()));
+            warning_showed = true;
+        }
+
         (move || {
             let remote_handle = remote_handle_cloned;
 

src/template.rs

@@ -1,94 +1,49 @@
 use std;
 use tera;
 use std::sync::RwLock;
-use time;
-use std::collections::HashMap;
 use serde_json;
+use logging;
 
 pub struct TemplateStorage {
-    engine: RwLock<tera::Tera>,
-    perf_info: RwLock<HashMap<String, PerfInfo>>
-}
-
-pub struct PerfInfo {
-    min_render_time: u64,
-    max_render_time: u64
+    engine: RwLock<tera::Tera>
 }
 
 impl TemplateStorage {
     pub fn new() -> TemplateStorage {
         TemplateStorage {
-            engine: RwLock::new(tera::Tera::default()),
-            perf_info: RwLock::new(HashMap::new())
+            engine: RwLock::new(tera::Tera::default())
         }
     }
 
     pub fn add(&self, name: &str, content: &str) -> bool {
+        let logger = logging::Logger::new("TemplateStorage::add");
+
         match self.engine.write().unwrap().add_raw_template(name, content) {
-            Ok(_) => true,
-            Err(_) => false
+            Ok(_) => {
+                logger.log(logging::Message::Info(format!("Template {} added", name)));
+                true
+            },
+            Err(e) => {
+                logger.log(logging::Message::Error(format!("Unable to add template {}: {:?}", name, e)));
+                false
+            }
         }
     }
 
     pub fn render_json(&self, name: &str, data: &str) -> Option<String> {
-        let start_time = time::micros();
+        let logger = logging::Logger::new("TemplateStorage::render_json");
 
         let data: serde_json::Value = match serde_json::from_str(data) {
             Ok(d) => d,
             Err(_) => return None
         };
-        let output = match self.engine.read().unwrap().render(name, &data) {
-            Ok(d) => d,
+        match self.engine.read().unwrap().render(name, &data) {
+            Ok(d) => Some(d),
             Err(e) => {
-                println!("Unable to render template {}: {:?}", name, e);
-                return None;
+                logger.log(logging::Message::Error(format!("Unable to render template {}: {:?}", name, e)));
+                None
             }
-        };
-
-        let end_time = time::micros();
-        let duration = end_time - start_time;
-
-        let mut update_perf_info = false;
-
-        let mut new_min: u64 = std::u64::MAX;
-        let mut new_max: u64 = 0;
-
-        {
-            let info = self.perf_info.read().unwrap();
-            match info.get(&name.to_string()) {
-                Some(v) => {
-                    new_min = v.min_render_time;
-                    new_max = v.max_render_time;
-                },
-                None => {}
-            };
-
-            if duration < new_min {
-                update_perf_info = true;
-                new_min = duration;
-            }
-            if duration > new_max {
-                update_perf_info = true;
-                new_max = duration;
-            }
-        }
-
-        if update_perf_info {
-            self.perf_info.write().unwrap().insert(name.to_string(), PerfInfo {
-                min_render_time: new_min,
-                max_render_time: new_max
-            });
         }
-
-        Some(output)
     }
 }
 
-impl PerfInfo {
-    fn new() -> PerfInfo {
-        PerfInfo {
-            min_render_time: std::u64::MAX,
-            max_render_time: 0
-        }
-    }
-}