add log and env_logger, add bunch of log calls

Author: Orciument

backend/Cargo.toml

@@ -25,3 +25,5 @@ twitch_highway = { version = "0.3.1", features = ["eventsub", "tokio", "bits", "
 serde_with = "3.15.1"
 asknothingx2-util = "0.1.10"
 tower = "0.5.2"
+env_logger = "0.11.8"
+log = "0.4.28"

backend/src/commands/command_controller.rs

@@ -11,6 +11,7 @@ use num_derive::FromPrimitive;
 use serde::{Deserialize, Serialize};
 use sqlx::Type;
 use std::str::FromStr;
+use log::{error, warn};
 use crate::commands::command_repo::SaveCommandError;
 use crate::state::L1Arc;
 
@@ -57,8 +58,8 @@ pub async fn get_all_user_commands(
     let commands = match search.search.as_deref() {
         Some("") | None => command_repo::get_all_commands_by_auto_generated(&state.l1.prod_db, false).await,
         Some(search) => command_repo::search_all_commands_by_is_auto_generated(&state.l1.prod_db, search, false).await,
-    }.map_err(|_| {
-        // log
+    }.map_err(|e| {
+        error!("{:?}", e);
         StatusCode::INTERNAL_SERVER_ERROR
     })?;
     Ok(Json(commands))
@@ -72,8 +73,8 @@ pub async fn get_all_commands(
     let commands = match search.search.as_deref() {
         Some("") | None => command_repo::get_all_commands(&l1.prod_db).await,
         Some(search) => command_repo::search_all_commands(&l1.prod_db, search).await,
-    }.map_err(|_| {
-        // log
+    }.map_err(|e| {
+        error!("{:?}", e);
         StatusCode::INTERNAL_SERVER_ERROR
     })?;
     Ok(Json(commands))
@@ -85,8 +86,8 @@ pub async fn get_by_trigger_id(
 ) -> AxResult<impl IntoResponse> {
     Ok(Json(command_repo::get_by_id(&l1.prod_db, trigger_id.as_ref())
         .await
-        .map_err(|_| {
-            // log
+        .map_err(|e| {
+            error!("{:?}", e);
             StatusCode::INTERNAL_SERVER_ERROR
         })?))
 }
@@ -100,8 +101,8 @@ pub async fn set_enabled(
     let enabled = bool::from_str(body.as_ref()).map_err(|_| StatusCode::BAD_REQUEST)?;
     command_repo::set_enabled(state.l1.as_ref(), trigger_id.as_ref(), enabled)
         .await
-        .map_err(|_| {
-            // log
+        .map_err(|e| {
+            error!("{:?}", e);
             StatusCode::INTERNAL_SERVER_ERROR
         })?
         .ok_or(StatusCode::NOT_FOUND)?;
@@ -116,8 +117,8 @@ pub async fn set_visible(
     let visible = bool::from_str(body.as_str()).map_err(|_| StatusCode::BAD_REQUEST)?;
     command_repo::set_visible(&l1.prod_db, trigger_id.as_str(), visible)
         .await
-        .map_err(|_| {
-            // log
+        .map_err(|e| {
+            error!("{:?}", e);
             StatusCode::INTERNAL_SERVER_ERROR
         })?
         .ok_or(StatusCode::NOT_FOUND)?;
@@ -130,12 +131,12 @@ pub async fn save(
 ) -> impl IntoResponse {
     match command_repo::save(l1.as_ref(), &to_save).await {
         Ok(()) => StatusCode::OK,
-        Err(SaveCommandError::DbError(_db_error)) => {
-            // log
+        Err(SaveCommandError::DbError(db_error)) => {
+            error!("Error saving command from panel: {:?}", db_error);
             StatusCode::INTERNAL_SERVER_ERROR
         }
-        Err(SaveCommandError::RegexError(_r)) => {
-            // log, but actually more return. This error needs to reach the user in the panel
+        Err(SaveCommandError::RegexError(r)) => {
+            warn!("User tried to save invalid regex: {:?}", r);
             //TODO figure out how to return this error to the user
             StatusCode::BAD_REQUEST
         }
@@ -146,8 +147,8 @@ pub async fn delete_by_id(
     l1: L1Arc,
     Path(trigger_id): Path<String>,
 ) -> AxResult<impl IntoResponse> {
-    command_repo::delete_by_id(l1.as_ref(), trigger_id.as_ref()).await.map_err(|_| {
-        // log
+    command_repo::delete_by_id(l1.as_ref(), trigger_id.as_ref()).await.map_err(|e| {
+        error!("Unable to execute command deletion: {:?}", e);
         StatusCode::INTERNAL_SERVER_ERROR
     })?;
     Ok(())

backend/src/commands/command_executor_service.rs

@@ -11,10 +11,11 @@ use std::collections::HashMap;
 use std::pin::Pin;
 use std::sync::Arc;
 use std::time::Instant;
+use log::{debug, error, trace, warn};
 use tokio::sync::RwLock;
 
 #[allow(dead_code)]
-#[derive(Clone, Copy, Ord, PartialOrd, PartialEq, Eq, Deserialize, Serialize, FromPrimitive, Type)]
+#[derive(Clone, Copy, Debug, Ord, PartialOrd, PartialEq, Eq, Deserialize, Serialize, FromPrimitive, Type)]
 #[repr(u8)]
 pub enum TwitchUserPermission {
     Everyone = 0,
@@ -113,15 +114,12 @@ pub struct CommandTrigger {
 
 static TEXT_COMMAND_CALLBACK: TriggerCallback = |app_state, trigger_id, _chat_message| Box::pin(async move {
     match TemplateService::get_template_by_trigger_id(&app_state.l1.prod_db, trigger_id.as_ref()).await {
-        Err(_e) => {
-            // log
-            // logger.debug("Executing text command {}", commandId);
+        Err(e) => error!("Could not fetch template for command {} from db: {:?}", trigger_id, e),
+        Ok(None) => warn!("Could not find template id for command id {}", trigger_id),
+        Ok(Some(t)) => {
+            debug!("Executing text command {}", trigger_id);
+            app_state.l2.twitch_service.send_raw_template(t.template.as_ref(), HashMap::new())
         }
-        Ok(None) => {
-            // log
-            // logger.error("Could not find template id for command id {}", commandId);
-        }
-        Ok(Some(t)) => app_state.l2.twitch_service.send_raw_template(t.template.as_ref(), HashMap::new())
     }
 });
 
@@ -187,7 +185,7 @@ impl  CommandExecutorService {
 
     async fn execute_trigger_if_matching(&self, app_state: Arc<FullState>, trigger: &CommandTrigger, chat_message: ChatMessage) {
         if chat_message.user.permission < trigger.permission {
-            // logger.debug("User {} with {}, missing {} permission for command {}", message.user().name(), message.user().permission(), trigger.permission(), trigger.id());
+            trace!("User {} with perm: {:?}, missing {:?} permission for command {}", chat_message.user.name, chat_message.user.permission, trigger.permission, trigger.id);
             return;
         }
 
@@ -197,8 +195,8 @@ impl  CommandExecutorService {
 
         let cooldown_res = self.cooldown_service.check_update_cooldown(&chat_message, trigger.id.as_ref(), &trigger.user_cooldown, &trigger.global_cooldown);
         if cooldown_res.is_some() {
-            // logger.debug("Call to command {} from {} rejected because of global cooldowns", trigger.id(), message.user().name());
-            // logger.debug("Call to command {} from {} rejected because of user cooldowns", trigger.id(), message.user().name());
+            trace!("Call to command {} from {} rejected because of global cooldowns", trigger.id, chat_message.user.name);
+            trace!("Call to command {} from {} rejected because of user cooldowns", trigger.id, chat_message.user.name);
             return;
         }
 

backend/src/commands/command_repo.rs

@@ -125,7 +125,7 @@ pub async fn search_all_commands(prod_db: &ProdDB, search: &str) -> anyhow::Resu
     "#, search_str, search_str, search_str, search_str)
         .fetch_all(prod_db.deref())
         .await
-        .context("failed to search table for all commands")?;
+        .with_context(|| format!("failed to search table for all commands; search: {}", search))?;
     get_patterns(prod_db, query_res).await
 }
 
@@ -156,7 +156,7 @@ pub async fn search_all_commands_by_is_auto_generated(prod_db: &ProdDB, search:
     "#, search_str, search_str, search_str, search_str, is_auto_generated)
         .fetch_all(prod_db.deref())
         .await
-        .context("failed to search table for all commands by is_auto_generated")?;
+        .with_context(|| format!("failed to search table for all commands by is_auto_generated; search: {}", search))?;
     get_patterns(prod_db, query_res).await
 }
 

backend/src/lib.rs

@@ -6,6 +6,7 @@ use service_oauth::oauth_service::OAuthService;
 use sqlx::MySqlPool;
 use std::str::FromStr;
 use std::sync::{Arc, OnceLock, RwLock};
+use log::error;
 use tokio::runtime::Handle;
 use tokio::sync::broadcast::error::RecvError;
 use url::Url;
@@ -22,7 +23,9 @@ mod service_oauth;
 mod twitch;
 mod state;
 
+
 pub async fn start() {
+    env_logger::init();
     //check if all mandatory configuration values are set
     //start mini webserver
 
@@ -75,20 +78,21 @@ pub async fn start() {
     let oauth = full.l1.oauth_service.new_oauth_request("twitch".to_string(), "account".to_string(), |_x, _x1| "".to_string());
     println!("oauth: {:?}", oauth);
 
-    let (command_channel, _) = tokio::sync::broadcast::channel::<Box<ChatMessage>>(20);
+    let (chat_channel, _) = tokio::sync::broadcast::channel::<Box<ChatMessage>>(20);
     // fanout of messages
     let full2 = full.clone();
-    let sender2 = command_channel.clone();
+    let sender2 = chat_channel.clone();
     Handle::current().spawn(async { TwitchService::start_websocket(full2, sender2) });
-    let mut receiver = command_channel.subscribe();
+
+    let mut receiver = chat_channel.subscribe();
     let full2 = full.clone();
     Handle::current().spawn(async move {
         loop {
             let message = match receiver.recv().await {
                 Ok(m) => *m,
                 Err(RecvError::Closed) => return,
-                Err(RecvError::Lagged(_s)) => {
-                    // log skip
+                Err(RecvError::Lagged(skipped)) => {
+                    error!("Twitch ChatMessage channel lagged, skipped {} messages!", skipped);
                     continue;
                 }
             };

backend/src/service_oauth/oauth_endpoint.rs

@@ -5,22 +5,11 @@ use axum::extract::{Path, Query, State};
 use axum::response::IntoResponse;
 use axum::response::Result as AxResult;
 use axum::Json;
+use log::error;
 use reqwest::StatusCode;
 use serde::Deserialize;
 use crate::state::L1Arc;
 
-/// Get redirect url for a particular service. The url is fully formed with the host accessible from the outside.
-///
-/// `service_name` is the string name/id of the service that you use to in [OAuthService::new_oauth_request]
-pub fn get_redirect_url(bot_base_url_config: String, service_name: &str) -> String {
-    bot_base_url_config + "/auth/" + service_name
-}
-
-/// Get the public url to the panel oauth setup page
-pub fn get_oauth_setup_url(bot_base_url_config: String) -> String {
-    bot_base_url_config + "/auth"
-}
-
 #[derive(Deserialize)]
 pub struct ReceiveOAuthQuery {
     state: String,
@@ -38,8 +27,8 @@ pub async fn receive_oauth(
     let panel_base_url = if let Ok(v) = state.l1.webserver_config.read() {
         v.panel_base_url.as_str().to_string()
     } else {
-        // log lock poisoned
-        return Err(StatusCode::INTERNAL_SERVER_ERROR)?;
+        error!("Error, webserver_config lock poisoned, unable to set panel redirect url");
+        "".to_string()
     };
     // Body:new( should be Redirect:to(& but for testing with postman, this is deactivated
     if query.error.is_some() || query.error_description.is_some() {
@@ -51,11 +40,12 @@ pub async fn receive_oauth(
     if query.code.is_none() {
         return Ok(Body::new(format!("{}?success=false&error={}", panel_base_url, url_encode("Query param code is required for non error Oauth response"))))
     }
-    Ok(Body::new(format!("{}{}", panel_base_url, match state.l1.oauth_service.return_oauth(service, query.state, query.scope.unwrap(), query.code.unwrap()) {
+    let result = state.l1.oauth_service.return_oauth(service, query.state, query.scope.unwrap(), query.code.unwrap());
+    Ok(Body::new(format!("{}{}", panel_base_url, match result {
         Ok(()) => format!("{}?success=true", panel_base_url),
         Err(OauthReturnError::NotRequested) => format!("{}?success=false&error={}", panel_base_url, url_encode("This oauth was never requested from the bot")),
         Err(OauthReturnError::ReturnChannelClosed) => {
-            eprintln!("Failed to process auth code, return channel was closed");
+            error!("Error, failed to process auth code, return channel was unexpectedly closed");
             format!("{}?success=false&error={}", panel_base_url, url_encode("Could not process auth code. Internal server error"))
         }
     })))

backend/src/twitch/authentication.rs

@@ -1,16 +1,12 @@
-use crate::axum::url_encode;
 use crate::twitch::twitch_service::OauthCredential;
-use crate::service_oauth::oauth_service::{AuthorizationUrl, AuthorizationUrlBuilder, OAuthService, OauthState};
 use anyhow::Context;
 use axum::http::method::Method;
 use axum::http::StatusCode;
 use serde::{Deserialize, Serialize};
 use serde_with::serde_as;
 use serde_with::DurationSeconds;
 use sqlx::types::chrono::Local;
-use std::str::FromStr;
 use std::time::Duration;
-use url::Url;
 
 #[serde_as]
 #[derive(Deserialize)]
@@ -101,20 +97,3 @@ pub async fn refresh_token(refresh_token: impl AsRef<str>, client_id: impl AsRef
         .context("Original response body: ".to_string() + &response_body)?;
     Ok(Some(validation_return))
 }
-
-pub fn authorization_url(client_id: impl AsRef<str>) -> Box<AuthorizationUrlBuilder> {
-    const TWITCH_AUTHORIZE: &'static str = "https://id.twitch.tv/oauth2/authorize";
-    const SCOPES: [&str; 6] = ["channel:bot", "user:bot", "moderator:read:chatters", "moderator:read:moderators", "user:read:chat", "user:manage:chat_color"];
-    let client_id = client_id.as_ref().to_string();
-    // Box::new( move |redirect, state| {
-    //     format!(r#"
-    //     {}
-    //     ?response_type=code
-    //     &client_id={}
-    //     &redirect_uri={}
-    //     &scope={}
-    //     &state={}
-    // "#, TWITCH_AUTHORIZE, client_id, redirect, SCOPES.map(url_encode).join("+"), state)
-    // })
-    todo!()
-}

backend/src/twitch/ideal_twitch_client.rs

@@ -13,6 +13,6 @@ enum SendChatError {
 
 impl Helix {
     pub async fn send_chat_message(broadcaster_id: impl AsRef<str>, sender_id: impl AsRef<str>, message: impl AsRef<str>, reply_parent_message_id: Option<impl AsRef<str>>, for_source_only: bool) -> Result<Vec<User>, SendChatError> {
-        todo!()
+        panic!("not implemented, just an example")
     }
 }

backend/src/twitch/twitch_api.rs

@@ -11,6 +11,7 @@ use twitch_highway::eventsub::{websocket, EventSubAPI, SubscriptionType};
 use tower::MakeService;
 use twitch_highway::eventsub::websocket::routes::{channel_chat_message, revocation, welcome};
 use anyhow::Context;
+use log::error;
 use crate::commands::command_executor_service::ChatMessage;
 use crate::state::FullState;
 use crate::twitch::twitch_service::TwitchService;
@@ -35,7 +36,9 @@ impl TwitchService {
             .with_state(state));
 
         let _ws = websocket::client("wss://eventsub.wss.twitch.tv/ws", twitch_router).await;
-        //log error
+        if let Err(e) = _ws {
+            error!("Unable to connect to twitch websocket: {:?}", e);
+        }
     }
 }
 

backend/src/twitch/twitch_service.rs

@@ -8,6 +8,7 @@ use serde::Deserialize;
 use sqlx::types::chrono::{DateTime, Local};
 use std::sync::Arc;
 use std::time::Instant;
+use log::{info, warn};
 use tokio::runtime::Handle;
 use tokio::sync::{Mutex, RwLock};
 use twitch_highway::TwitchAPI;
@@ -54,8 +55,8 @@ impl TwitchService {
         };
         let oauth = match Self::check_or_get_oauth(&cred_from_db, &l1.prod_db, &twitch_config).await {
             Ok(oauth) => oauth,
-            Err(_e) => {
-                // log err
+            Err(e) => {
+                warn!("Twitch Oauth credentials from DB invalid, and could not be refreshed: {:?}", e);
                 TwitchCredentialStatus {
                     was_valid_at_check: true,
                     valid_checked_at: Instant::now(),
@@ -104,6 +105,7 @@ impl TwitchService {
                             let twitch_api = self.twitch_api.clone();
                             let token_validation = self.token_validation.clone();
                             Handle::current().spawn(async move {
+                                info!("Awaiting manual reauthorization of twitch account oauth!");
                                 let credential = TwitchService::request_new_oauth(&l1, config).await;
                                 {
                                     let mut api_lock = twitch_api.write().await;
@@ -115,7 +117,7 @@ impl TwitchService {
                                     token_lock.was_valid_at_check = true;
                                     token_lock.credential = credential;
                                 }
-                                //log
+                                info!("Successfully get, refreshed, and set new Oauth Token for Twitch Client");
                             });
                             return Err(e).context("Credentials Bad, not retrying");
                         }