Add logging

Cargo.toml

@@ -8,3 +8,6 @@ hlua = "0.3"
 discord = "0.7.0"
 toml = "0.2.1"
 crossbeam = "0.2"
+rand = "0.3"
+log = "0.3.6"
+env_logger = "0.4.0"

src/helpers/mod.rs

@@ -0,0 +1,13 @@
+use event::Event;
+
+pub fn reply_to (event: Event, reply: &str) {
+    match event {
+        Event::Message { content: message, channel, sender } => {
+            match channel {
+                Some(channel) => channel.send(reply),
+                None => sender.send(reply)
+            }
+        }
+        _ => ()
+    }
+}

src/lib.rs

@@ -19,6 +19,9 @@ use std::sync::mpsc::Sender;
 
 mod helpers;
 
+#[macro_use]
+extern crate log;
+
 pub struct Tenquestionmarks {
     modules: BTreeMap<String, Box<Module>>
 }
@@ -72,10 +75,13 @@ impl Tenquestionmarks {
                 match receiver.recv() {
                     Ok(event) => {
                         for sender in &senders {
-                            sender.send(event.clone());
+                            match sender.send(event.clone()) {
+                                Err(err) => debug!("Failed to dispatch event to module: {:?}", err),
+                                Ok(_) => {}
+                            }
                         }
                     },
-                    Err(_) => {}
+                    Err(err) => { error!("Failed to receive event in main event loop: {:?}", err); }
                 }
             }
         });

src/main.rs

@@ -8,7 +8,13 @@ use tenquestionmarks::Tenquestionmarks;
 extern crate toml;
 use toml::Parser;
 
+#[macro_use]
+extern crate log;
+extern crate env_logger;
+
 fn main () {
+    env_logger::init().unwrap();
+
     let configFileName = env::args().nth(1).unwrap_or("tenquestionmarks.toml".into());
     match File::open(&configFileName) {
         Ok(mut file) => {
@@ -18,27 +24,27 @@ fn main () {
                     let mut parser = Parser::new(&contents);
                     match parser.parse() {
                         Some(configuration) => {
-                            println!("Loaded configuration from: {}", configFileName);
+                            info!("Loaded configuration from: {}", configFileName);
                             match Tenquestionmarks::from_configuration(configuration) {
                                 Ok(tqm) => {
-                                    println!("tenquestionmarks initialized successfully");
+                                    info!("tenquestionmarks initialized successfully");
                                     tqm.run();
                                 },
-                                Err(e) => println!("Failed to initialize tenquestionmarks: {:?}", e)
+                                Err(e) => error!("Failed to initialize tenquestionmarks: {:?}", e)
                             }
                         },
                         None => {
-                            println!("Failed to parse config file {}: {:?}. Config file must be a valid TOML file.", configFileName, parser.errors);
+                            error!("Failed to parse config file {}: {:?}. Config file must be a valid TOML file.", configFileName, parser.errors);
                         }
                     }
                 },
                 Err(e) => {
-                    println!("Failed to open config file {}: {:?}", configFileName, e);
+                    error!("Failed to open config file {}: {:?}", configFileName, e);
                 }
             }
         },
         Err(e) => {
-            println!("Failed to open config file! Please specify path to a config file.");
+            error!("Failed to open config file! Please specify path to a config file.");
         }
     }
 }

src/modules/discord.rs

@@ -37,14 +37,18 @@ pub struct DiscordMessageSender {
 
 impl MessageSender for DiscordMessageSender {
     fn send_message (&self, message: &str) {
-        self.discord.send_message(&self.channel_id, message, "", false);
+        debug!("Send message to channel id {:?}: {:?}", self.channel_id, message);
+        match self.discord.send_message(&self.channel_id, message, "", false) {
+            Ok(message) => { debug!("Send message succeeded: {:?}", message.id); },
+            Err(err) => { error!("Send message failed: {:?}", err) }
+        }
     }
 }
 
 impl Module for DiscordModule {
     fn produce_events<'a>(&'a self, sender: Sender<event::Event>) {
-        let discord = Arc::new(Discord::from_bot_token(&self.token[..]).expect("Login failed"));
-        let (mut connection, _) = discord.connect().expect("Connection failed");
+        let discord = Arc::new(Discord::from_bot_token(&self.token[..]).expect("Discord module: Login failed"));
+        let (mut connection, _) = discord.connect().expect("Discord module: Connection failed");
         loop {
             match connection.recv_event() {
                 Ok(Event::MessageCreate(message)) => {
@@ -66,14 +70,17 @@ impl Module for DiscordModule {
                         })
                     };
 
-                    sender.send(event::Event::Message { sender: author, content: message.content, channel: Option::Some(channel) });
+                    match sender.send(event::Event::Message { sender: author, content: message.content, channel: Option::Some(channel) }) {
+                        Err(err) => error!("Error sending message event: {:?}", err),
+                        Ok(_) => {}
+                    }
                 }
     			Ok(_) => {}
     			Err(discord::Error::Closed(code, body)) => {
-	                println!("Gateway closed on us with code {:?}: {}", code, body);
+	                error!("Gateway closed on us with code {:?}: {}", code, body);
     				break
     			}
-    			Err(err) => println!("Receive error: {:?}", err)
+    			Err(err) => error!("Received error: {:?}", err)
             }
         }
     }

src/modules/echo.rs

@@ -27,6 +27,7 @@ impl Module for EchoModule {
                 Ok(event) => {
                     match event {
                         Event::Message { content: message, channel, sender } => {
+                            debug!("Received message... {:?}", message);
                             if message.starts_with(self.prefix.as_str()) {
                                 let substring = &message[self.prefix.chars().count()..];
                                 match channel {
@@ -38,7 +39,7 @@ impl Module for EchoModule {
                         _ => ()
                     }
                 }
-                Err(error) => { }
+                Err(error) => { error!("Error {:?}", error) }
             }
         }
     }

src/modules/random.rs

@@ -41,9 +41,10 @@ impl Module for RandomModule {
                 Ok(event) => {
                     match event {
                         Event::Message { content: message, channel, sender } => {
+                            debug!("Received message... {:?}", message);
                             if message.starts_with(self.prefix.as_str()) {
                                 let response = &rand::sample(&mut rng, &self.responses, 1)[0][..];
-                                
+
                                 match channel {
                                     Some(channel) => channel.send(response),
                                     None => sender.send(response)
@@ -53,7 +54,7 @@ impl Module for RandomModule {
                         _ => ()
                     }
                 }
-                Err(error) => { }
+                Err(error) => { error!("Error {:?}", error) }
             }
         }
     }

src/modules/stdin.rs

@@ -18,7 +18,8 @@ pub struct StdinMessageSender {
 
 impl MessageSender for StdinMessageSender {
     fn send_message (&self, message: &str) {
-        println!("send to {:?}: {:?}", self.name, message);
+        debug!("Send message to stdout: {:?}", message);
+        println!("{}: {}", self.name, message);
     }
 }
 
@@ -42,9 +43,12 @@ impl Module for StdinModule {
             match io::stdin().read_line(&mut input) {
                 Ok(n) => {
                     let message = Event::Message { sender: user.clone(), content: input, channel: None };
-                    sender.send(message);
+                    match sender.send(message) {
+                        Err(err) => error!("Error sending message event: {:?}", err),
+                        Ok(_) => {}
+                    }
                 }
-                Err(error) => println!("error: {}", error),
+                Err(error) => error!("error: {}", error),
             }
         }
     }