feat(error_handling): log event errors to Discord

Author: ryanccn

src/commands/fun/shiggy.rs

@@ -1,7 +1,7 @@
 use poise::{serenity_prelude as serenity, CreateReply};
 
 use crate::{utils::error_handling::ValfiskError, Context};
-use color_eyre::eyre::Result;
+use color_eyre::eyre::{Report, Result};
 
 #[derive(serde::Deserialize)]
 struct SafebooruResponse {
@@ -55,8 +55,9 @@ pub async fn shiggy(
         }
 
         Err(err) => {
-            let err = color_eyre::eyre::Report::from(err);
-            let valfisk_err = ValfiskError::new(&err, &ctx);
+            let err = Report::from(err);
+
+            let valfisk_err = ValfiskError::error(&err, &ctx);
             valfisk_err.handle_log();
             valfisk_err.handle_report().await;
 

src/handlers/error_handling.rs

@@ -1,22 +1,51 @@
 use tracing::error;
 
-use poise::FrameworkError;
+use poise::{
+    serenity_prelude::{CacheHttp, CreateEmbed, CreateMessage, Timestamp},
+    FrameworkError,
+};
 
-use crate::{utils::error_handling::ValfiskError, Data};
+use crate::{
+    utils::error_handling::{ValfiskError, ERROR_LOGS_CHANNEL},
+    Data,
+};
 
 #[tracing::instrument(skip(err))]
 pub async fn handle_error(err: FrameworkError<'_, Data, color_eyre::eyre::Report>) {
     match err {
-        FrameworkError::EventHandler { error, .. } => {
+        FrameworkError::EventHandler {
+            error,
+            event,
+            framework,
+            ..
+        } => {
             error!("{:?}", error);
+
+            let embed = CreateEmbed::default()
+                .title("An error occurred in an event handler!")
+                .description(format!(
+                    "### Error\n```\n{error:#?}\n```\n### Event\n```\n{event:#?}\n```"
+                ))
+                .timestamp(Timestamp::now())
+                .color(0xff6b6b);
+
+            if let Some(channel) = *ERROR_LOGS_CHANNEL {
+                channel
+                    .send_message(
+                        framework.serenity_context.http(),
+                        CreateMessage::default().embed(embed),
+                    )
+                    .await
+                    .ok();
+            }
         }
 
         FrameworkError::Command { error, ctx, .. } => {
-            ValfiskError::new(&error, &ctx).handle_all().await;
+            ValfiskError::error(&error, &ctx).handle_all().await;
         }
 
         FrameworkError::CommandPanic { payload, ctx, .. } => {
-            ValfiskError::new(&payload, &ctx).handle_all().await;
+            ValfiskError::panic(&payload, &ctx).handle_all().await;
         }
 
         _ => {}

src/utils/error_handling.rs

@@ -1,3 +1,4 @@
+use once_cell::sync::Lazy;
 use std::fmt::Debug;
 
 use nanoid::nanoid;
@@ -17,18 +18,6 @@ pub enum ErrorOrPanic<'a> {
     Panic(&'a Option<String>),
 }
 
-impl<'a> From<&'a color_eyre::eyre::Error> for ErrorOrPanic<'a> {
-    fn from(val: &'a color_eyre::eyre::Error) -> Self {
-        ErrorOrPanic::Error(val)
-    }
-}
-
-impl<'a> From<&'a Option<String>> for ErrorOrPanic<'a> {
-    fn from(val: &'a Option<String>) -> Self {
-        ErrorOrPanic::Panic(val)
-    }
-}
-
 impl ErrorOrPanic<'_> {
     /// Return whether `self` is a panic or an error.
     fn type_string(&self) -> String {
@@ -39,6 +28,12 @@ impl ErrorOrPanic<'_> {
     }
 }
 
+pub static ERROR_LOGS_CHANNEL: Lazy<Option<ChannelId>> = Lazy::new(|| {
+    std::env::var("ERROR_LOGS_CHANNEL")
+        .ok()
+        .and_then(|s| s.parse::<ChannelId>().ok())
+});
+
 /// A wrapped type around errors or panics encapsulated in [`ErrorOrPanic`] that includes context from Poise and a randomly generated `error_id`.
 #[derive(Debug)]
 pub struct ValfiskError<'a> {
@@ -51,14 +46,21 @@ pub struct ValfiskError<'a> {
 }
 
 impl ValfiskError<'_> {
-    /// Create a new [`ValfiskError`] from an error or a panic string and Poise context.
+    /// Create a new [`ValfiskError`] from an error and Poise context.
     #[must_use]
-    pub fn new<'a>(
-        error_or_panic: impl Into<ErrorOrPanic<'a>>,
-        ctx: &'a Context,
-    ) -> ValfiskError<'a> {
+    pub fn error<'a>(error: &'a color_eyre::eyre::Error, ctx: &'a Context) -> ValfiskError<'a> {
         ValfiskError {
-            error_or_panic: error_or_panic.into(),
+            error_or_panic: ErrorOrPanic::Error(error),
+            ctx,
+            error_id: nanoid!(8),
+        }
+    }
+
+    /// Create a new [`ValfiskError`] from a panic string and Poise context.
+    #[must_use]
+    pub fn panic<'a>(panic: &'a Option<String>, ctx: &'a Context) -> ValfiskError<'a> {
+        ValfiskError {
+            error_or_panic: ErrorOrPanic::Panic(panic),
             ctx,
             error_id: nanoid!(8),
         }
@@ -91,14 +93,7 @@ impl ValfiskError<'_> {
     /// Report the error to a channel defined through the environment variable `ERROR_LOGS_CHANNEL`.
     #[tracing::instrument(skip(self))]
     pub async fn handle_report(&self) {
-        if let Ok(channel_id) = match std::env::var("ERROR_LOGS_CHANNEL") {
-            Ok(channel_id_str) => channel_id_str
-                .parse::<u64>()
-                .map_err(color_eyre::eyre::Error::from),
-            Err(err) => Err(color_eyre::eyre::Error::from(err)),
-        } {
-            let channel = ChannelId::new(channel_id);
-
+        if let Some(channel) = *ERROR_LOGS_CHANNEL {
             let embed = CreateEmbed::default()
                 .title("An error occurred!")
                 .description(format!("```\n{:#?}\n```", self.error_or_panic))