refactor(ping): add more info in ping command

Akinator31 · Akinator31 · commit 7978a8cd355d · 2025-11-18T09:49:31.000+01:00
diff --git a/rustmail/src/commands/ping/slash_command/ping.rs b/rustmail/src/commands/ping/slash_command/ping.rs
@@ -1,15 +1,17 @@
-use std::collections::HashMap;
 use crate::bot::ShardManagerKey;
 use crate::commands::{BoxFuture, CommunityRegistrable, RegistrableCommand};
 use crate::config::Config;
 use crate::errors::{DiscordError, ModmailError, ModmailResult};
 use crate::handlers::InteractionHandler;
 use crate::i18n::get_translated_message;
+use crate::utils::{MessageBuilder, defer_response};
+use chrono::Utc;
 use serenity::FutureExt;
 use serenity::all::{CommandInteraction, Context, CreateCommand, ResolvedOption};
+use std::collections::HashMap;
 use std::sync::Arc;
 use std::time::Duration;
-use crate::utils::{defer_response, MessageBuilder};
+use tokio::time::Instant;
 
 pub struct PingCommand;
 
@@ -60,30 +62,58 @@ impl RegistrableCommand for PingCommand {
 
         Box::pin(async move {
             defer_response(&ctx, &command).await?;
+            let response = MessageBuilder::system_message(&ctx, &config)
+                .content("...")
+                .to_channel(command.channel_id)
+                .build_interaction_message_followup()
+                .await;
 
             let shard_manager = ctx
                 .data
                 .read()
                 .await
                 .get::<ShardManagerKey>()
-                .unwrap()
-                .clone();
+                .cloned()
+                .ok_or(ModmailError::Discord(DiscordError::ShardManagerNotFound))?;
 
-            let latency = {
+            let time_before = Instant::now();
+            let mut res = command.create_followup(&ctx.http, response).await?;
+            let msg_send_ping = time_before.elapsed().as_millis();
+
+            let gateway_ping = {
                 let runners = shard_manager.runners.lock().await;
                 runners.get(&ctx.shard_id).and_then(|runner| runner.latency)
             };
 
+            let start = Instant::now();
+            ctx.http.get_gateway().await?;
+            let api_ping = start.elapsed();
+
             let mut params = HashMap::new();
-            params.insert("latency".to_string(), format!("{:?}", latency.unwrap_or(Duration::default()).as_millis()));
+            params.insert(
+                "gateway_latency".to_string(),
+                format!(
+                    "{:?}",
+                    gateway_ping.unwrap_or(Duration::default()).as_millis()
+                ),
+            );
+            params.insert(
+                "api_latency".to_string(),
+                format!("{:?}", api_ping.as_millis()),
+            );
+            params.insert(
+                "message_latency".to_string(),
+                format!("{:?}", msg_send_ping),
+            );
 
             let response = MessageBuilder::system_message(&ctx, &config)
-                .translated_content("slash_command.ping_command", Some(&params), None, None).await
+                .translated_content("slash_command.ping_command", Some(&params), None, None)
+                .await
                 .to_channel(command.channel_id)
-                .build_interaction_message_followup().await;
+                .build_edit_message()
+                .await;
 
-            command.create_followup(&ctx.http, response).await
-                .map_err(|e| ModmailError::Discord(DiscordError::ApiError(e.to_string())))?;
+            res.edit(&ctx.http, response).await?;
 
             Ok(())
         })
diff --git a/rustmail/src/commands/ping/text_command/ping.rs b/rustmail/src/commands/ping/text_command/ping.rs
@@ -1,12 +1,14 @@
-use std::collections::HashMap;
 use crate::bot::ShardManagerKey;
 use crate::prelude::config::*;
 use crate::prelude::errors::*;
 use crate::prelude::handlers::*;
+use crate::utils::MessageBuilder;
+use chrono::Utc;
 use serenity::all::{Context, Message};
+use std::collections::HashMap;
 use std::sync::Arc;
 use std::time::Duration;
-use crate::utils::MessageBuilder;
+use tokio::time::Instant;
 
 pub async fn ping(
     ctx: Context,
@@ -19,22 +21,47 @@ pub async fn ping(
         .read()
         .await
         .get::<ShardManagerKey>()
-        .unwrap()
-        .clone();
+        .cloned()
+        .ok_or(ModmailError::Discord(DiscordError::ShardManagerNotFound))?;
 
-    let latency = {
+    let time_before = Instant::now();
+    let mut res = msg.reply(&ctx.http, "...").await?;
+    let msg_send_ping = time_before.elapsed().as_millis();
+
+    let gateway_ping = {
         let runners = shard_manager.runners.lock().await;
         runners.get(&ctx.shard_id).and_then(|runner| runner.latency)
     };
 
+    let start = Instant::now();
+    ctx.http.get_gateway().await?;
+    let api_ping = start.elapsed();
+
     let mut params = HashMap::new();
-    params.insert("latency".to_string(), format!("{:?}", latency.unwrap_or(Duration::default()).as_millis()));
+    params.insert(
+        "gateway_latency".to_string(),
+        format!(
+            "{:?}",
+            gateway_ping.unwrap_or(Duration::default()).as_millis()
+        ),
+    );
+    params.insert(
+        "api_latency".to_string(),
+        format!("{:?}", api_ping.as_millis()),
+    );
+    params.insert(
+        "message_latency".to_string(),
+        format!("{:?}", msg_send_ping),
+    );
 
-    let _ = MessageBuilder::system_message(&ctx, &config)
-        .translated_content("slash_command.ping_command", Some(&params), None, None).await
+    let edited_msg = MessageBuilder::system_message(&ctx, &config)
+        .translated_content("slash_command.ping_command", Some(&params), None, None)
+        .await
         .to_channel(msg.channel_id)
-        .send(true).await
-        .map_err(|e| ModmailError::Discord(DiscordError::ApiError(e.to_string())))?;
+        .build_edit_message()
+        .await;
+
+    res.edit(&ctx.http, edited_msg).await?;
 
     Ok(())
 }
diff --git a/rustmail/src/errors/dictionary.rs b/rustmail/src/errors/dictionary.rs
@@ -188,6 +188,9 @@ impl DictionaryManager {
                 DiscordError::UserIsABot => ("discord.user_is_a_bot".to_string(), None),
                 DiscordError::PermissionDenied => ("discord.permission_denied".to_string(), None),
                 DiscordError::DmCreationFailed => ("discord.dm_creation_failed".to_string(), None),
+                DiscordError::ShardManagerNotFound => {
+                    ("discord.shard_manager_not_found".to_string(), None)
+                }
                 _ => ("discord.api_error".to_string(), None),
             },
             ModmailError::Command(cmd_err) => match cmd_err {
diff --git a/rustmail/src/errors/types.rs b/rustmail/src/errors/types.rs
@@ -56,6 +56,7 @@ pub enum DiscordError {
     DmCreationFailed,
     FailedToFetchCategories,
     FailedToMoveChannel,
+    ShardManagerNotFound,
 }
 
 #[derive(Debug, Clone)]
@@ -198,6 +199,7 @@ impl fmt::Display for DiscordError {
             DiscordError::DmCreationFailed => write!(f, "Failed to create DM channel"),
             DiscordError::FailedToFetchCategories => write!(f, "Failed to fetch categories"),
             DiscordError::FailedToMoveChannel => write!(f, "Failed to move_thread channel"),
+            DiscordError::ShardManagerNotFound => write!(f, "Shard manager not found"),
         }
     }
 }
diff --git a/rustmail/src/i18n/language/en.rs b/rustmail/src/i18n/language/en.rs
@@ -50,6 +50,10 @@ pub fn load_english_messages(dict: &mut ErrorDictionary) {
         "discord.user_is_a_bot".to_string(),
         DictionaryMessage::new("The specified user is a rustmail."),
     );
+    dict.messages.insert(
+        "discord.shard_manager_not_found".to_string(),
+        DictionaryMessage::new("Shard manager not found."),
+    );
     dict.messages.insert(
         "command.invalid_format".to_string(),
         DictionaryMessage::new("Invalid command format")
@@ -885,7 +889,7 @@ pub fn load_english_messages(dict: &mut ErrorDictionary) {
     );
     dict.messages.insert(
         "help.ping".to_string(),
-        DictionaryMessage::new("Show the actual latency of the bot."),
+        DictionaryMessage::new("Shows the actual latency of the bot."),
     );
     dict.messages.insert(
         "add_reminder.helper".to_string(),
@@ -934,10 +938,10 @@ pub fn load_english_messages(dict: &mut ErrorDictionary) {
     );
     dict.messages.insert(
         "slash_command.ping_command_desc".to_string(),
-        DictionaryMessage::new("Check the discord bot latency."),
+        DictionaryMessage::new("Check the Discord bot latency."),
     );
     dict.messages.insert(
         "slash_command.ping_command".to_string(),
-        DictionaryMessage::new("The Discord bot latency is **{latency}** ms."),
+        DictionaryMessage::new("## Latency\n\nGateway latency: **{gateway_latency}** ms\nMinimal REST latency (GET /gateway): **{api_latency}** ms\nREST latency (message send): **{message_latency}** ms"),
     );
 }
diff --git a/rustmail/src/i18n/language/fr.rs b/rustmail/src/i18n/language/fr.rs
@@ -45,6 +45,10 @@ pub fn load_french_messages(dict: &mut ErrorDictionary) {
         "discord.user_is_a_bot".to_string(),
         DictionaryMessage::new("L'utilisateur spécifié est un rustmail"),
     );
+    dict.messages.insert(
+        "discord.shard_manager_not_found".to_string(),
+        DictionaryMessage::new("Shard manager non trouvé."),
+    );
     dict.messages.insert(
         "command.invalid_format".to_string(),
         DictionaryMessage::new("Format de commande invalide")
@@ -950,6 +954,6 @@ pub fn load_french_messages(dict: &mut ErrorDictionary) {
     );
     dict.messages.insert(
         "slash_command.ping_command".to_string(),
-        DictionaryMessage::new("La latence actuelle du bot est de **{latency}** ms."),
+        DictionaryMessage::new("## Latence\n\nLatence Gateway : **{gateway_latency}** ms.\nLatence REST minimale (GET /gateway) : **{api_latency}** ms.\nLatence REST (envoi d'un message) : **{message_latency}** ms."),
     );
 }
diff --git a/rustmail/src/utils/message/message_builder.rs b/rustmail/src/utils/message/message_builder.rs
@@ -531,6 +531,7 @@ impl<'a> MessageBuilder<'a> {
 
         if self.should_use_embed().await {
             message = message.embed(self.build_embed().await);
+            message = message.content("");
         } else {
             let content = self.build_plain_message();
             if !content.is_empty() {
@@ -550,6 +551,7 @@ impl<'a> MessageBuilder<'a> {
 
         if self.should_use_embed().await {
             message = message.embed(self.build_embed().await);
+            message = message.content("");
         } else {
             let content = self.build_plain_message();
             if !content.is_empty() {
@@ -571,6 +573,7 @@ impl<'a> MessageBuilder<'a> {
 
         if self.should_use_embed().await {
             message = message.embed(self.build_embed().await);
+            message = message.content("");
         } else {
             let content = self.build_plain_message();
             if !content.is_empty() {

Original file line number	Diff line number	Diff line change
`@@ -56,6 +56,7 @@ pub enum DiscordError {`
`56`	`56`	`DmCreationFailed,`
`57`	`57`	`FailedToFetchCategories,`
`58`	`58`	`FailedToMoveChannel,`
	`59`	`+ ShardManagerNotFound,`
`59`	`60`	`}`
`60`	`61`
`61`	`62`	`#[derive(Debug, Clone)]`
`@@ -198,6 +199,7 @@ impl fmt::Display for DiscordError {`
`198`	`199`	`DiscordError::DmCreationFailed => write!(f, "Failed to create DM channel"),`
`199`	`200`	`DiscordError::FailedToFetchCategories => write!(f, "Failed to fetch categories"),`
`200`	`201`	`DiscordError::FailedToMoveChannel => write!(f, "Failed to move_thread channel"),`
	`202`	`+ DiscordError::ShardManagerNotFound => write!(f, "Shard manager not found"),`
`201`	`203`	`}`
`202`	`204`	`}`
`203`	`205`	`}`