Add logging

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),
             }
         }
     }