rework logpump to actually work

add in webhook support for speedy embed logs
add timestamps and more info

Author: AEnterprise

Cargo.lock

@@ -34,6 +34,10 @@ twilight-embed-builder = "0.2"
 twilight-gateway = {version="0.2", default-features=false, features=["rustls", "simd-json", "simd-zlib"]}
 twilight-http = "0.2"
 twilight-model = "0.2"
+#twilight-embed-builder = { git="https://github.com/Erk-/twilight", branch="fix/webhook-execute-204-broken"}
+#twilight-gateway = { git="https://github.com/Erk-/twilight", branch="fix/webhook-execute-204-broken"}
+#twilight-http = { git="https://github.com/Erk-/twilight", branch="fix/webhook-execute-204-broken"}
+#twilight-model = { git="https://github.com/Erk-/twilight", branch="fix/webhook-execute-204-broken"}
 url = "2.1"
 unic-langid = { version = "0.9", features = ["macros", "serde"] }
 uuid = { version = "0.8", features = ["serde", "v4"], default_features = false }

Cargo.toml

@@ -86,3 +86,10 @@ create table guildConfig
     config jsonb not null,
     encryption_key bytea not null
 );
+
+create table webhook
+(
+    channel_id bigint primary key not null,
+    id bigint not null,
+    token varchar(255) not null
+)

migrations/1_inital.sql

@@ -63,4 +63,31 @@ impl CachedUser {
             && self.system_user == user.system.unwrap_or(false)
             && self.public_flags == user.public_flags
     }
+
+    pub fn full_name(&self) -> String {
+        format!("{}#{}", self.username, self.discriminator)
+    }
+
+    pub fn full_name_with_id(&self) -> String {
+        format!("{}#{} ({})", self.username, self.discriminator, self.id)
+    }
+
+    pub fn profile_link(&self) -> String {
+        format!("https://discord.com/users/{}", self.id)
+    }
+
+    pub fn avatar_url(&self) -> String {
+        match &self.avatar {
+            Some(avatar) => format!(
+                "https://cdn.discordapp.com/avatars/{}/{}.{}",
+                self.id,
+                avatar,
+                if avatar.starts_with("a_") { "gif" } else { "png" }
+            ),
+            None => format!(
+                "https://cdn.discordapp.com/embed/avatar/{}.png",
+                &self.discriminator.parse::<u16>().unwrap() % 5
+            ),
+        }
+    }
 }

src/cache/user.rs

@@ -3,7 +3,12 @@ use crate::core::CommandContext;
 use crate::error::CommandResult;
 
 pub async fn test(mut ctx: CommandContext) -> CommandResult {
-    let arg = ctx.parser.get_remaining();
-    ctx.log(LogType::TEST(arg), None, None);
+    ctx.log(
+        LogType::CommandUsed {
+            command: "test".to_string(),
+        },
+        Some(ctx.message.channel.get_id()),
+        ctx.message.author.id,
+    );
     Ok(())
 }

src/commands/debug/test.rs

@@ -152,6 +152,8 @@ impl BotContext {
     }
 
     pub fn log(&self, data: LogData) {
-        self.logpump_sender.send(data);
+        // can only error if the other side is closed, and we never close the main receiver
+        let _ = self.logpump_sender.send(data);
+        self.stats.logpump_stats.pending_logs.inc();
     }
 }

src/core/bot_context/mod.rs

@@ -1,16 +1,21 @@
 use std::sync::Arc;
 
 use twilight_model::guild::Permissions;
-use twilight_model::id::UserId;
+use twilight_model::id::{ChannelId, GuildId, UserId};
 
 use super::BotContext;
 use crate::cache::{CachedGuild, CachedMember};
 use crate::commands::meta::nodes::{CommandNode, GearBotPermissions};
 use crate::commands::ROOT_NODE;
 use crate::core::guild_config::{GuildConfig, PermissionGroup};
+use twilight_model::channel::permission_overwrite::PermissionOverwriteType;
 
 impl BotContext {
-    pub fn get_guild_permissions_for(&self, member: &Arc<CachedMember>, guild: &Arc<CachedGuild>) -> Permissions {
+    pub fn get_guild_permissions_for_member(
+        &self,
+        member: &Arc<CachedMember>,
+        guild: &Arc<CachedGuild>,
+    ) -> Permissions {
         //owners can do whatever they want
         if guild.owner_id == member.user_id {
             return Permissions::all();
@@ -31,6 +36,76 @@ impl BotContext {
         }
     }
 
+    pub fn get_guild_permissions_for(&self, guild_id: &GuildId, user_id: &UserId) -> Permissions {
+        match self.cache.get_guild(guild_id) {
+            Some(guild) => match self.cache.get_member(guild_id, user_id) {
+                Some(member) => self.get_guild_permissions_for_member(&member, &guild),
+                None => Permissions::empty(),
+            },
+            None => Permissions::empty(),
+        }
+    }
+
+    pub fn get_channel_permissions_for(&self, user_id: UserId, channel_id: ChannelId) -> Permissions {
+        if let Some(channel) = self.cache.get_channel(channel_id) {
+            if channel.is_dm() {
+                return Permissions::SEND_MESSAGES
+                    | Permissions::EMBED_LINKS
+                    | Permissions::ATTACH_FILES
+                    | Permissions::USE_EXTERNAL_EMOJIS
+                    | Permissions::ADD_REACTIONS
+                    | Permissions::READ_MESSAGE_HISTORY;
+            }
+
+            let mut permissions = self.get_guild_permissions_for(&channel.get_guild_id().unwrap(), &user_id);
+            //admins don't give a **** about overrides
+            if permissions.contains(Permissions::ADMINISTRATOR) {
+                return Permissions::all();
+            }
+            if let Some(member) = &self.cache.get_member(&channel.get_guild_id().unwrap(), &user_id) {
+                let overrides = channel.get_permission_overrides();
+                let mut everyone_allowed = Permissions::empty();
+                let mut everyone_denied = Permissions::empty();
+                let mut user_allowed = Permissions::empty();
+                let mut user_denied = Permissions::empty();
+                let mut role_allowed = Permissions::empty();
+                let mut role_denied = Permissions::empty();
+                for o in overrides {
+                    match o.kind {
+                        PermissionOverwriteType::Member(member_id) => {
+                            if member_id == user_id {
+                                user_allowed |= o.allow;
+                                user_denied |= o.deny;
+                            }
+                        }
+                        PermissionOverwriteType::Role(role_id) => {
+                            if role_id.0 == channel.get_guild_id().unwrap().0 {
+                                everyone_allowed |= o.allow;
+                                everyone_denied |= o.deny
+                            } else if member.roles.contains(&role_id) {
+                                role_allowed |= o.allow;
+                                role_denied |= o.deny;
+                            }
+                        }
+                    }
+                }
+
+                permissions &= !everyone_denied;
+                permissions |= everyone_allowed;
+
+                permissions &= !role_denied;
+                permissions |= role_allowed;
+
+                permissions &= !user_denied;
+                permissions |= user_allowed;
+            };
+
+            permissions
+        } else {
+            Permissions::empty()
+        }
+    }
+
     pub fn get_permissions_for(
         &self,
         guild: &Arc<CachedGuild>,
@@ -40,7 +115,7 @@ impl BotContext {
         let mut permissions = GearBotPermissions::empty();
         let mut not_negated_denies = GearBotPermissions::empty();
 
-        let discord_permissions = self.get_guild_permissions_for(member, guild);
+        let discord_permissions = self.get_guild_permissions_for_member(member, guild);
 
         //these are already sorted by priority upon loading
         for group in &config.permission_groups {
@@ -120,7 +195,7 @@ fn cascade_node(
     // also when the parent is not available
     // unless we have an explicit grant
     let denied = not_negated_denies.contains(node.command_permission)
-        || !parent_available && !permissions.contains(node.command_permission);
+        || !parent_available & &!permissions.contains(node.command_permission);
 
     if !denied {
         permissions.insert(node.command_permission)
@@ -133,7 +208,7 @@ fn cascade_node(
         }
     }
     // we did not have this command, we do have one of it's subcommands and this command does not do anything itself, grant access as it only gives help info
-    if denied && !not_negated_denies.contains(node.command_permission) && any_granted && node.handler.is_none() {
+    if denied & &!not_negated_denies.contains(node.command_permission) & &any_granted & &node.handler.is_none() {
         permissions.insert(node.command_permission)
     }
 }

src/core/bot_context/permissions.rs

@@ -7,6 +7,7 @@ use super::{BotContext, ShardState};
 use crate::GIT_VERSION;
 use prometheus::{IntCounter, IntCounterVec, IntGauge, IntGaugeVec, Opts, Registry};
 
+use crate::core::guild_config::{LogCategory, LogStyle};
 use log::info;
 use std::collections::HashMap;
 use twilight_model::gateway::event::Event;
@@ -79,6 +80,17 @@ pub struct ShardStats {
     pub disconnected: IntGauge,
 }
 
+pub struct LogpumpStats {
+    pub active_pumps: IntGauge,
+    pub pending_logs: IntGauge,
+    pub embed: LogTypeCounters,
+    pub text: LogTypeCounters,
+}
+
+pub struct LogTypeCounters {
+    pub general: IntCounter,
+}
+
 pub struct BotStats {
     pub registry: Registry,
     pub start_time: DateTime<Utc>,
@@ -93,20 +105,24 @@ pub struct BotStats {
     pub role_count: IntGauge,
     pub command_counts: IntCounterVec,
     pub total_command_counts: AtomicU64,
+    pub logpump_stats: LogpumpStats,
 }
 
 impl BotStats {
     #[rustfmt::skip]
     pub fn new(cluster_id: u64) -> Self {
         let event_counter = IntCounterVec::new(Opts::new("gateway_events", "Events received from the gateway"), &["events"]).unwrap();
-        let message_counter = IntCounterVec::new(Opts::new("messages", "Recieved messages"), &["sender_type"]).unwrap();
+        let message_counter = IntCounterVec::new(Opts::new("messages", "Received messages"), &["sender_type"]).unwrap();
         let channel_count = IntGauge::with_opts(Opts::new("channels", "Channel count")).unwrap();
         let emoji_count = IntGauge::with_opts(Opts::new("emoji", "Emoji count")).unwrap();
         let role_count = IntGauge::with_opts(Opts::new("roles", "Role count")).unwrap();
         let guild_counter = IntGaugeVec::new(Opts::new("guild_counts", "State of the guilds"), &["state"]).unwrap();
         let user_counter = IntGaugeVec::new(Opts::new("user_counts", "User counts"), &["type"]).unwrap();
         let shard_counter = IntGaugeVec::new(Opts::new("shard_counts", "State counts for our shards"), &["state"]).unwrap();
         let command_counts = IntCounterVec::new(Opts::new("commands", "Executed commands"), &["name"]).unwrap();
+        let active_pumps = IntGauge::with_opts(Opts::new("active_pumps", "Active logpumps")).unwrap();
+        let pending_logs = IntGauge::with_opts(Opts::new("pending_logs", "Pending log messages")).unwrap();
+        let pumped_logs = IntCounterVec::new(Opts::new("pumped_logs", "Successfully send logs"), &["type", "category"]).unwrap();
 
         let mut static_labels = HashMap::new();
         static_labels.insert(String::from("cluster"), cluster_id.to_string());
@@ -120,6 +136,10 @@ impl BotStats {
         registry.register(Box::new(user_counter.clone())).unwrap();
         registry.register(Box::new(shard_counter.clone())).unwrap();
         registry.register(Box::new(command_counts.clone())).unwrap();
+        registry.register(Box::new(active_pumps.clone())).unwrap();
+        registry.register(Box::new(pending_logs.clone())).unwrap();
+        registry.register(Box::new(pumped_logs.clone())).unwrap();
+
         BotStats {
             registry,
             start_time: Utc::now(),
@@ -188,10 +208,20 @@ impl BotStats {
                 ready: shard_counter.get_metric_with_label_values(&["ready"]).unwrap(),
                 resuming: shard_counter.get_metric_with_label_values(&["resuming"]).unwrap(),
                 reconnecting: shard_counter.get_metric_with_label_values(&["reconnecting"]).unwrap(),
-                disconnected: shard_counter.get_metric_with_label_values(&["disconnected"]).unwrap()
+                disconnected: shard_counter.get_metric_with_label_values(&["disconnected"]).unwrap(),
             },
             command_counts,
             total_command_counts: AtomicU64::new(0),
+            logpump_stats: LogpumpStats {
+                active_pumps,
+                pending_logs,
+                embed: LogTypeCounters {
+                    general: pumped_logs.get_metric_with_label_values(&["embed", "general"]).unwrap()
+                },
+                text: LogTypeCounters {
+                    general: pumped_logs.get_metric_with_label_values(&["text", "general"]).unwrap()
+                }
+            },
         }
     }
 
@@ -210,6 +240,13 @@ impl BotStats {
             self.message_counts.user_messages.inc()
         }
     }
+
+    pub async fn logpump_logged(&self, log_style: &LogStyle, category: &LogCategory) {
+        match (log_style, category) {
+            (LogStyle::Text, LogCategory::GENERAL) => self.logpump_stats.text.general.inc(),
+            (LogStyle::Embed, LogCategory::GENERAL) => self.logpump_stats.embed.general.inc(),
+        }
+    }
 }
 
 impl BotContext {

src/core/bot_context/stats.rs

@@ -133,7 +133,7 @@ impl CommandContext {
         &self,
         log_type: LogType,
         source_channel: Option<ChannelId>,
-        source_user: Option<UserId>,
+        source_user: UserId,
     ) -> Result<(), CommandError> {
         log::debug!("Logging {:?}", log_type);
         self.bot_context.log(LogData {