1 files changed, 20 insertions, 9 deletions

diff --git a/src/system/mod.rs b/src/system/mod.rs
index f5327e3..8e642ea 100644
--- a/src/system/mod.rs
+++ b/src/system/mod.rs
@@ -2,10 +2,12 @@ mod aggregator;
 mod types;
 mod plugin;
 mod util;
+mod log;
 
+use aggregator::MemberEvent;
+use log::Logger;
 use twilight_gateway::{Intents, Shard, ShardId};
 use twilight_http::Client;
-use twilight_model::channel::Message;
 pub use types::SystemThreadCommand;
 use crate::SystemUiEvent;
 use std::{num::NonZeroU64, sync::Arc};
@@ -35,6 +37,7 @@ impl Manager {
         };
 
         let mut message_receiver = aggregator::MessageAggregator::start(&system);
+        let logger = Logger::new(system_name.clone(), system_config.clone(), ui_sender.clone());
 
         let mut plugins : Vec<Box<dyn SeancePlugin>> = vec![
             Box::new(plugin::ProxyPrefixes),
@@ -44,15 +47,24 @@ impl Manager {
         loop {
             match message_receiver.recv().await {
                 None => (),
-                Some((message, seen_by)) => {
-                    println!("Checking message: {}", message.content.clone());
+                Some(MemberEvent::GatewayConnect(member_token)) => {
+                    logger.log_connect(member_token).await;
+                },
+                Some(MemberEvent::GatewayError(member_token)) => {
+                    logger.log_err(Some(member_token), "Non-fatal gateway error".to_string()).await;
+                },
+                Some(MemberEvent::GatewayDisconnect(member_token)) => {
+                    logger.log_disconnect(member_token).await;
+                },
+                Some(MemberEvent::Message(message, seen_by)) => {
                     if message.content.starts_with(&system.command_prefix) {
+                        logger.log_line(None, format!("Handling command: {}", message.content)).await;
                         for plugin in &mut plugins {
-                            match plugin.handle_command(&system, &message).await {
+                            match plugin.handle_command(&logger, &system, &message).await {
                                 plugin::CommandOutcome::Skipped => continue,
                                 plugin::CommandOutcome::Handled => break,
                                 plugin::CommandOutcome::Errored {message} => {
-                                    println!("Error: {message}");
+                                    logger.log_err(None, message).await;
                                     break
                                 },
                             }
@@ -60,13 +72,12 @@ impl Manager {
                     } else {
                         let mut message_response = Response::Noop { delete_source: false };
                         for plugin in &plugins {
-                            plugin.handle_message(&system, &message, &mut message_response).await;
+                            plugin.handle_message(&logger, &system, &message, &mut message_response).await;
                         }
 
                         match message_response.clone() {
                             Response::Noop { delete_source } => {
                                 if delete_source {
-                                    println!("Deleting source message");
                                     let client = system.members.iter().find(|m| m.discord_token == seen_by).map(|m| m.client.clone())
                                         .expect("No such client");
 
@@ -77,12 +88,12 @@ impl Manager {
                             Response::Proxy { member, content } => {
                                 if let Ok(new_message) = util::duplicate_message(&member.client, &message, content.as_str()).await {
                                     if let Err(err) = {member.client.lock().await.delete_message(message.channel_id, message.id).await.map(|_| ()).map_err(|err| err.to_string()).clone() } {
-                                        println!("Error proxying message: {err}");
+                                        logger.log_err(Some(member.discord_token), format!("Could not proxy message: {err}")).await;
                                         {let _ = member.client.lock().await.delete_message(new_message.channel_id, new_message.id).await;}
                                     }
 
                                     for plugin in &plugins {
-                                        plugin.post_response(&system, &new_message, message.channel_id, &message_response).await;
+                                        plugin.post_response(&logger, &system, &new_message, message.channel_id, &message_response).await;
                                     }
                                 }
                             },