""" RubyLogging - The most comprehensive Discord event logging system. Tracks every single Discord event with individual toggles, filtering, and formatting. """ import asyncio import logging from datetime import datetime, timezone from typing import Any, Dict, List, Optional, Tuple, Union import discord from redbot.core import Config, commands from redbot.core.bot import Red from redbot.core.utils.chat_formatting import box, humanize_list, pagify LOG = logging.getLogger("red.evecogs.rubylogging") # All Discord events organized by category EVENTS = { "connection": [ "connect", "disconnect", "resumed", "shard_connect", "shard_disconnect", "shard_ready", "shard_resumed", ], "gateway": [ "socket_event_type", "socket_raw_receive", "socket_raw_send", ], "guilds": [ "guild_available", "guild_join", "guild_remove", "guild_unavailable", "guild_update", "guild_role_create", "guild_role_delete", "guild_role_update", "guild_emojis_update", "guild_stickers_update", "guild_integrations_update", ], "channels": [ "guild_channel_create", "guild_channel_delete", "guild_channel_update", "guild_channel_pins_update", "private_channel_create", "private_channel_delete", "private_channel_update", "private_channel_pins_update", "group_join", "group_remove", ], "members": [ "member_join", "member_remove", "member_update", "member_ban", "member_unban", "user_update", "presence_update", ], "messages": [ "message", "message_delete", "message_edit", "raw_message_delete", "raw_message_edit", "raw_bulk_message_delete", "reaction_add", "reaction_remove", "reaction_clear", "reaction_clear_emoji", "raw_reaction_add", "raw_reaction_remove", "raw_reaction_clear", "raw_reaction_clear_emoji", ], "voice": [ "voice_state_update", ], "stage": [ "stage_instance_create", "stage_instance_delete", "stage_instance_update", ], "threads": [ "thread_create", "thread_delete", "thread_join", "thread_member_join", "thread_member_remove", "thread_remove", "thread_update", "raw_thread_delete", "raw_thread_member_remove", "raw_thread_update", ], "interactions": [ "interaction", ], "integrations": [ "integration_create", "integration_update", "integration_delete", "webhooks_update", "raw_integration_delete", ], "invites": [ "invite_create", "invite_delete", ], "typing": [ "typing", ], "automod": [ "automod_rule_create", "automod_rule_update", "automod_rule_delete", "automod_action_execution", ], "scheduled_events": [ "scheduled_event_create", "scheduled_event_delete", "scheduled_event_update", "scheduled_event_user_add", "scheduled_event_user_remove", ], "app_commands": [ "app_command_completion", ], "entitlements": [ "entitlement_create", "entitlement_update", "entitlement_delete", ], "audit_log": [ "audit_log_entry_create", ], } class RubyLogging(commands.Cog): """The ultimate Discord event logging system - every event, individually toggleable.""" def __init__(self, bot: Red): self.bot = bot self.config = Config.get_conf( self, identifier=0x5255425954524143, force_registration=True ) # Default settings default_guild = { "log_channel": None, "enabled_events": [], "disabled_categories": [], "format": "detailed", # detailed, compact, json "include_timestamp": True, "color_coded": True, "ignore_bots": False, "ignore_users": [], "ignore_channels": [], "filter_patterns": [], # Attachment logging "log_attachments": True, "log_stickers": True, "show_attachment_previews": True, "track_deleted_attachments": True, "max_preview_attachments": 4, "reupload_attachments": True, # Re-upload images to preserve them } self.config.register_guild(**default_guild) # Event handler registry self._handlers = {} self._register_all_handlers() # Attachment cache for deleted messages (message_id -> attachments) self._attachment_cache: Dict[int, List[Dict[str, Any]]] = {} self._cache_max_size = 1000 def _register_all_handlers(self) -> None: """Dynamically register all event handlers.""" for category, events in EVENTS.items(): for event in events: # Skip message events - we handle those specially for attachment tracking if event in ("message_delete", "raw_bulk_message_delete"): continue handler_name = f"_log_{event}" # Create dynamic handler async def handler(*args, _event=event, _category=category, **kwargs): await self._process_event(_event, _category, *args, **kwargs) # Store and register setattr(self, handler_name, handler) self.bot.add_listener(handler, f"on_{event}") self._handlers[event] = handler # Register special handlers for attachment tracking # These replace the default message_delete and bulk_delete handlers self.bot.add_listener(self._cache_message_attachments, "on_message") self.bot.add_listener(self._handle_message_delete_with_cache, "on_message_delete") self.bot.add_listener(self._handle_bulk_delete_with_cache, "on_bulk_message_delete") async def cog_unload(self) -> None: """Remove all registered event listeners.""" for event, handler in self._handlers.items(): self.bot.remove_listener(handler, f"on_{event}") # Remove special attachment handlers self.bot.remove_listener(self._cache_message_attachments, "on_message") self.bot.remove_listener(self._handle_message_delete_with_cache, "on_message_delete") self.bot.remove_listener(self._handle_bulk_delete_with_cache, "on_bulk_message_delete") # Clear attachment cache self._attachment_cache.clear() # ═══════════════════════════════════════════════════════════════════════ # Attachment Caching for Deleted Messages # ═══════════════════════════════════════════════════════════════════════ async def _cache_message_attachments(self, message: discord.Message) -> None: """Cache message attachments for later retrieval if deleted.""" if not message.guild: return # Check if attachment tracking is enabled try: config = self.config.guild(message.guild) if not await config.track_deleted_attachments(): return except Exception: return # Only cache if message has attachments or stickers if not message.attachments and not message.stickers: return # Build attachment data attachment_data = [] for att in message.attachments: # For images/GIFs, store both URL and proxy URL # Proxy URLs tend to last longer after deletion is_image = att.content_type.startswith("image/") if att.content_type else att.filename.lower().endswith(('.png', '.jpg', '.jpeg', '.gif', '.webp')) is_gif = att.content_type == "image/gif" if att.content_type else att.filename.lower().endswith(".gif") attachment_data.append({ "filename": att.filename, "url": att.url, "proxy_url": att.proxy_url, # This persists longer! "size": att.size, "content_type": att.content_type, "is_image": is_image, "is_video": att.content_type.startswith("video/") if att.content_type else False, "is_gif": is_gif, "width": att.width, "height": att.height, "ephemeral": att.ephemeral if hasattr(att, 'ephemeral') else False, }) # Add stickers for sticker in message.stickers: attachment_data.append({ "filename": f"{sticker.name}.png", "url": sticker.url, "proxy_url": sticker.url, "size": 0, "content_type": "sticker", "is_image": True, "is_video": False, "is_gif": sticker.format == discord.StickerFormatType.gif if hasattr(sticker, 'format') else False, "width": None, "height": None, "sticker_id": sticker.id, "sticker_name": sticker.name, }) # Store in cache self._attachment_cache[message.id] = attachment_data # Prevent unbounded growth if len(self._attachment_cache) > self._cache_max_size: # Remove oldest entries (first 100) oldest_keys = list(self._attachment_cache.keys())[:100] for key in oldest_keys: self._attachment_cache.pop(key, None) async def _handle_message_delete_with_cache(self, message: discord.Message) -> None: """Handle message deletion with cached attachment data.""" if not message.guild: return # Peek (don't evict yet) — discord.Message uses __slots__, so cached # data can't be stashed as an extra attribute on the message object. # _build_embed() looks this up from self._attachment_cache by message # id instead, so the entry needs to still be there while it runs. cached = self._attachment_cache.get(message.id) # Process the normal message_delete event (this will show the preview if cached) await self._process_event("message_delete", "messages", message) # Also log detailed attachment info if enabled if cached: config = self.config.guild(message.guild) if await config.log_attachments(): await self._log_deleted_attachments(message, cached) # Now safe to evict — nothing below this point needs it. self._attachment_cache.pop(message.id, None) async def _handle_bulk_delete_with_cache(self, messages: List[discord.Message]) -> None: """Handle bulk message deletion with cached attachments.""" if not messages: return guild = messages[0].guild if messages else None if not guild: return # Process normal bulk delete event await self._process_event("raw_bulk_message_delete", "messages", messages) # Check for any cached attachments deleted_with_attachments = [] for message in messages: cached = self._attachment_cache.pop(message.id, None) if cached: deleted_with_attachments.append((message, cached)) if deleted_with_attachments: await self._log_bulk_deleted_attachments(guild, deleted_with_attachments) async def _log_deleted_attachments( self, message: discord.Message, attachments: List[Dict[str, Any]] ) -> None: """Log deleted message attachments with previews.""" if not message.guild: return config = self.config.guild(message.guild) # Check if attachment logging is enabled if not await config.log_attachments(): return enabled_events = await config.enabled_events() if "message_delete" not in enabled_events: return channel_id = await config.log_channel() if not channel_id: return channel = message.guild.get_channel(channel_id) if not channel or not isinstance(channel, discord.TextChannel): return # Apply filters if await self._should_ignore(message.guild, [message], {}): return # Check if we should re-upload attachments reupload = await config.reupload_attachments() # Build embed color_coded = await config.color_coded() include_timestamp = await config.include_timestamp() color = discord.Color.red() if color_coded else discord.Color.greyple() embed = discord.Embed( title="📎 Deleted Message Had Attachments", color=color, ) if include_timestamp: embed.timestamp = datetime.now(timezone.utc) embed.add_field( name="Message Info", value=( f"**Author:** {message.author.mention} (`{message.author.id}`)\n" f"**Channel:** {message.channel.mention}\n" f"**Message ID:** `{message.id}`" ), inline=False, ) # List all attachments attachment_lines = [] images_for_preview = [] show_previews = await config.show_attachment_previews() max_previews = await config.max_preview_attachments() for i, att in enumerate(attachments, 1): size_mb = att["size"] / 1024 / 1024 type_emoji = "🖼️" if att["is_image"] else "🎬" if att["is_video"] else "📎" if att["content_type"] == "sticker": type_str = "Sticker" # Use proxy URL for stickers url = att.get('proxy_url') or att['url'] attachment_lines.append( f"{type_emoji} **{att['sticker_name']}** (Sticker)\n" f"╰ [View]({url})" ) else: if att["is_gif"]: type_str = "GIF" type_emoji = "🎞️" elif att["is_image"]: type_str = "Image" elif att["is_video"]: type_str = "Video" else: type_str = att["content_type"] or "File" dims = "" if att["width"] and att["height"]: dims = f" ({att['width']}x{att['height']})" # Use proxy URL which persists longer url = att.get('proxy_url') or att['url'] attachment_lines.append( f"{type_emoji} **{att['filename']}** ({size_mb:.2f} MB)\n" f"╰ Type: {type_str}{dims} · [View]({url})" ) # Collect images for preview - use proxy URL! if show_previews and att["is_image"] and len(images_for_preview) < max_previews: preview_url = att.get('proxy_url') or att['url'] images_for_preview.append(preview_url) embed.add_field( name=f"📋 Attachments ({len(attachments)})", value="\n\n".join(attachment_lines)[:1024], inline=False, ) # Add preview for first image if images_for_preview: embed.set_image(url=images_for_preview[0]) try: # If reupload is enabled, download and re-upload images to preserve them files_to_upload = [] if reupload and images_for_preview: import aiohttp import io async with aiohttp.ClientSession() as session: for i, url in enumerate(images_for_preview[:max_previews]): try: async with session.get(url) as resp: if resp.status == 200: data = await resp.read() # Get filename from attachment data filename = attachments[i].get('filename', f'image_{i}.png') file = discord.File(io.BytesIO(data), filename=filename) files_to_upload.append(file) except Exception as e: LOG.warning(f"Failed to download attachment for re-upload: {e}") # Send main embed with re-uploaded files if files_to_upload: # Send with files attached - they'll be preserved! sent_msg = await channel.send(embed=embed, files=files_to_upload[:10]) # Discord limit else: # Fall back to URL embedding (will expire) sent_msg = await channel.send(embed=embed) # Send additional previews if multiple images (as separate embeds) if len(images_for_preview) > 1: for i, preview_url in enumerate(images_for_preview[1:max_previews], 2): preview_embed = discord.Embed( description=f"**Attachment {i}/{min(len(images_for_preview), max_previews)}**", color=color ) preview_embed.set_image(url=preview_url) await channel.send(embed=preview_embed) except discord.HTTPException as e: LOG.error(f"Failed to send deleted attachment log: {e}") except Exception as e: LOG.exception(f"Error processing deleted attachments: {e}") async def _log_bulk_deleted_attachments( self, guild: discord.Guild, deleted_data: List[Tuple[discord.Message, List[Dict[str, Any]]]] ) -> None: """Log bulk deleted attachments.""" config = self.config.guild(guild) if not await config.log_attachments(): return channel_id = await config.log_channel() if not channel_id: return channel = guild.get_channel(channel_id) if not channel or not isinstance(channel, discord.TextChannel): return color_coded = await config.color_coded() color = discord.Color.red() if color_coded else discord.Color.greyple() embed = discord.Embed( title="🗑️ Bulk Delete - Attachments Lost", description=f"**{len(deleted_data)}** deleted messages contained attachments", color=color, timestamp=datetime.now(timezone.utc), ) summary_lines = [] total_attachments = 0 for message, attachments in deleted_data[:10]: # Show first 10 total_attachments += len(attachments) summary_lines.append( f"**{message.author}** in {message.channel.mention}\n" f"╰ {len(attachments)} attachment(s) · Message ID: `{message.id}`" ) if len(deleted_data) > 10: summary_lines.append(f"\n*...and {len(deleted_data) - 10} more messages with attachments*") embed.add_field( name=f"📎 Total Attachments Lost: {total_attachments}", value="\n\n".join(summary_lines)[:1024], inline=False, ) try: await channel.send(embed=embed) except discord.HTTPException as e: LOG.error(f"Failed to send bulk deleted attachments log: {e}") # ═══════════════════════════════════════════════════════════════════════ # Event Processing Core # ═══════════════════════════════════════════════════════════════════════ async def _process_event( self, event_name: str, category: str, *args, **kwargs ) -> None: """Process and log an event if enabled.""" # Handle both positional and keyword arguments all_args = list(args) # Get guild context from event data guild = self._extract_guild(all_args, kwargs) if not guild: return # Check if event is enabled enabled_events = await self.config.guild(guild).enabled_events() if event_name not in enabled_events: return # Check if category is disabled disabled_categories = await self.config.guild(guild).disabled_categories() if category in disabled_categories: return # Get log channel channel_id = await self.config.guild(guild).log_channel() if not channel_id: return channel = guild.get_channel(channel_id) if not channel or not isinstance(channel, discord.TextChannel): return # Apply filters if await self._should_ignore(guild, all_args, kwargs): return # Format and send log try: embed = await self._format_event( guild, event_name, category, all_args, kwargs ) await channel.send(embed=embed) except discord.HTTPException as e: LOG.error(f"Failed to send log for {event_name}: {e}") except Exception as e: LOG.exception(f"Error processing {event_name}: {e}") def _extract_guild( self, args: List[Any], kwargs: Dict[str, Any] ) -> Optional[discord.Guild]: """Extract guild from event arguments.""" # Try to find guild in arguments for arg in args: if isinstance(arg, discord.Guild): return arg if hasattr(arg, "guild") and isinstance(arg.guild, discord.Guild): return arg.guild # Try keyword arguments for value in kwargs.values(): if isinstance(value, discord.Guild): return value if hasattr(value, "guild") and isinstance(value.guild, discord.Guild): return value.guild return None async def _should_ignore( self, guild: discord.Guild, args: List[Any], kwargs: Dict[str, Any] ) -> bool: """Check if event should be ignored based on filters.""" config = self.config.guild(guild) # Check bot filter ignore_bots = await config.ignore_bots() if ignore_bots: for arg in args: if isinstance(arg, (discord.User, discord.Member)) and arg.bot: return True # Check user filter ignore_users = await config.ignore_users() if ignore_users: for arg in args: if isinstance(arg, (discord.User, discord.Member)): if arg.id in ignore_users: return True # Check channel filter ignore_channels = await config.ignore_channels() if ignore_channels: for arg in args: if isinstance(arg, discord.abc.GuildChannel): if arg.id in ignore_channels: return True if hasattr(arg, "channel") and isinstance( arg.channel, discord.abc.GuildChannel ): if arg.channel.id in ignore_channels: return True return False async def _format_event( self, guild: discord.Guild, event_name: str, category: str, args: List[Any], kwargs: Dict[str, Any], ) -> Union[discord.Embed, List[discord.Embed]]: """Format event data into a beautiful, detailed embed.""" config = self.config.guild(guild) format_type = await config.format() color_coded = await config.color_coded() include_timestamp = await config.include_timestamp() # Enhanced color mapping with specific event colors colors = { "connection": discord.Color.from_rgb(88, 101, 242), # Blurple "gateway": discord.Color.from_rgb(153, 170, 181), # Grey "guilds": discord.Color.from_rgb(138, 43, 226), # Purple "channels": discord.Color.from_rgb(87, 242, 135), # Green "members": discord.Color.from_rgb(255, 165, 0), # Orange "messages": discord.Color.from_rgb(255, 215, 0), # Gold "voice": discord.Color.from_rgb(114, 137, 218), # Light blurple "stage": discord.Color.from_rgb(255, 115, 250), # Magenta "threads": discord.Color.from_rgb(32, 178, 170), # Teal "interactions": discord.Color.from_rgb(237, 66, 69), # Brand red "integrations": discord.Color.from_rgb(218, 165, 32), # Dark gold "invites": discord.Color.from_rgb(211, 211, 211), # Light grey "typing": discord.Color.from_rgb(192, 192, 192), # Silver "automod": discord.Color.from_rgb(255, 0, 0), # Pure red "scheduled_events": discord.Color.from_rgb(75, 0, 130), # Indigo "app_commands": discord.Color.from_rgb(87, 242, 135), # Brand green "entitlements": discord.Color.from_rgb(255, 223, 0), # Yellow "audit_log": discord.Color.from_rgb(139, 0, 0), # Dark red } color = colors.get(category, discord.Color.greyple()) if color_coded else discord.Color.greyple() # Enhanced title with category emoji category_emojis = { "connection": "🔌", "gateway": "📡", "guilds": "🏰", "channels": "💬", "members": "👥", "messages": "📨", "voice": "🔊", "stage": "🎙️", "threads": "🧵", "interactions": "⚡", "integrations": "🔗", "invites": "📨", "typing": "⌨️", "automod": "🛡️", "scheduled_events": "📅", "app_commands": "⚙️", "entitlements": "💎", "audit_log": "📜", } emoji = category_emojis.get(category, "📋") title = f"{emoji} {event_name.replace('_', ' ').title()}" embed = discord.Embed( title=title, color=color, ) if include_timestamp: embed.timestamp = datetime.now(timezone.utc) # Add category badge in footer embed.set_footer( text=f"{category.upper()} • on_{event_name}", icon_url=guild.icon.url if guild.icon else None ) # Format event data based on format type if format_type == "detailed": await self._add_detailed_fields(embed, event_name, args, kwargs) elif format_type == "compact": await self._add_compact_fields(embed, event_name, args, kwargs) elif format_type == "json": await self._add_json_fields(embed, event_name, args, kwargs) # Add image preview for messages with attachments preview_url = None if args and isinstance(args[0], discord.Message): msg = args[0] # First check for cached attachments (for deleted messages) — looked # up by message id, since discord.Message uses __slots__ and can't # hold an extra attribute stashed onto the object itself. cached = self._attachment_cache.get(msg.id) if cached: for att_data in cached: if att_data.get('is_image'): # Use proxy URL which lasts longer preview_url = att_data.get('proxy_url') or att_data.get('url') break # Otherwise check current attachments elif msg.attachments: for att in msg.attachments: if att.content_type and att.content_type.startswith("image/"): # Use proxy URL for better persistence preview_url = att.proxy_url or att.url break if preview_url: embed.set_image(url=preview_url) return embed async def _add_detailed_fields( self, embed: discord.Embed, event_name: str, args: List[Any], kwargs: Dict[str, Any] ) -> None: """Add detailed field information to embed with before/after comparisons.""" # Special handling for update events (before, after pattern) if "_update" in event_name and len(args) == 2: before, after = args[0], args[1] # For message edits, show a compact changes summary instead of full before/after if isinstance(before, discord.Message) and isinstance(after, discord.Message): changes = await self._detect_changes(before, after) if changes: changes_str = "\n".join(f"• {change}" for change in changes) if len(changes_str) > 1024: changes_str = changes_str[:1021] + "..." embed.add_field(name="📝 Message Edit", value=changes_str, inline=False) # Add message context context = ( f"**Author:** {after.author.mention}\n" f"**Channel:** {after.channel.mention if hasattr(after.channel, 'mention') else after.channel}\n" f"**Message ID:** `{after.id}`\n" f"**[Jump to Message]({after.jump_url})**" ) embed.add_field(name="📍 Context", value=context, inline=False) else: # Standard before/after for other updates # Add before state before_str = await self._format_object(before) if len(before_str) > 1024: before_str = before_str[:1021] + "..." embed.add_field(name="📤 Before", value=before_str, inline=False) # Add after state after_str = await self._format_object(after) if len(after_str) > 1024: after_str = after_str[:1021] + "..." embed.add_field(name="📥 After", value=after_str, inline=False) # Add a changes summary for member/guild/role updates changes = await self._detect_changes(before, after) if changes: changes_str = "\n".join(f"• {change}" for change in changes) if len(changes_str) > 1024: changes_str = changes_str[:1021] + "..." embed.add_field(name="🔄 Changes Detected", value=changes_str, inline=False) else: # Standard argument parsing for i, arg in enumerate(args): name = f"Argument {i + 1}" value = await self._format_object(arg) if len(value) > 1024: value = value[:1021] + "..." embed.add_field(name=name, value=value, inline=False) for key, value in kwargs.items(): formatted = await self._format_object(value) if len(formatted) > 1024: formatted = formatted[:1021] + "..." embed.add_field(name=key.title(), value=formatted, inline=False) async def _detect_changes(self, before: Any, after: Any) -> List[str]: """Detect specific changes between before and after objects.""" changes = [] if isinstance(before, discord.Member) and isinstance(after, discord.Member): if before.nick != after.nick: changes.append(f"**Nickname:** `{before.nick or 'None'}` → `{after.nick or 'None'}`") if before.roles != after.roles: added = set(after.roles) - set(before.roles) removed = set(before.roles) - set(after.roles) if added: changes.append(f"**Roles Added:** {', '.join(r.mention for r in added)}") if removed: changes.append(f"**Roles Removed:** {', '.join(r.mention for r in removed)}") if before.status != after.status: changes.append(f"**Status:** {before.status.name} → {after.status.name}") if hasattr(before, 'timed_out_until') and before.timed_out_until != after.timed_out_until: if after.timed_out_until: until = f"" changes.append(f"**Timeout:** Set until {until}") else: changes.append("**Timeout:** Removed") elif isinstance(before, discord.User) and isinstance(after, discord.User): if before.name != after.name: changes.append(f"**Username:** `{before.name}` → `{after.name}`") if before.discriminator != after.discriminator: changes.append(f"**Discriminator:** `{before.discriminator}` → `{after.discriminator}`") if before.avatar != after.avatar: changes.append("**Avatar:** Changed") elif isinstance(before, discord.Guild) and isinstance(after, discord.Guild): if before.name != after.name: changes.append(f"**Name:** `{before.name}` → `{after.name}`") if before.icon != after.icon: changes.append("**Icon:** Changed") if before.owner_id != after.owner_id: changes.append(f"**Owner:** <@{before.owner_id}> → <@{after.owner_id}>") if before.premium_tier != after.premium_tier: changes.append(f"**Boost Level:** {before.premium_tier} → {after.premium_tier}") if before.verification_level != after.verification_level: changes.append(f"**Verification:** {before.verification_level.name} → {after.verification_level.name}") elif isinstance(before, discord.Role) and isinstance(after, discord.Role): if before.name != after.name: changes.append(f"**Name:** `{before.name}` → `{after.name}`") if before.color != after.color: changes.append(f"**Color:** {before.color} → {after.color}") if before.hoist != after.hoist: changes.append(f"**Hoisted:** {before.hoist} → {after.hoist}") if before.mentionable != after.mentionable: changes.append(f"**Mentionable:** {before.mentionable} → {after.mentionable}") if before.permissions != after.permissions: changes.append("**Permissions:** Modified") elif isinstance(before, (discord.TextChannel, discord.VoiceChannel)) and isinstance(after, (discord.TextChannel, discord.VoiceChannel)): if before.name != after.name: changes.append(f"**Name:** `{before.name}` → `{after.name}`") if before.category != after.category: before_cat = before.category.name if before.category else "None" after_cat = after.category.name if after.category else "None" changes.append(f"**Category:** {before_cat} → {after_cat}") if isinstance(before, discord.TextChannel) and isinstance(after, discord.TextChannel): if before.slowmode_delay != after.slowmode_delay: changes.append(f"**Slowmode:** {before.slowmode_delay}s → {after.slowmode_delay}s") if before.nsfw != after.nsfw: changes.append(f"**NSFW:** {before.nsfw} → {after.nsfw}") if isinstance(before, discord.VoiceChannel) and isinstance(after, discord.VoiceChannel): if before.user_limit != after.user_limit: before_limit = before.user_limit or "Unlimited" after_limit = after.user_limit or "Unlimited" changes.append(f"**User Limit:** {before_limit} → {after_limit}") if before.bitrate != after.bitrate: changes.append(f"**Bitrate:** {before.bitrate//1000}kbps → {after.bitrate//1000}kbps") elif isinstance(before, discord.Message) and isinstance(after, discord.Message): if before.content != after.content: old_content = before.content[:200] + "..." if len(before.content) > 200 else before.content or "*No text*" new_content = after.content[:200] + "..." if len(after.content) > 200 else after.content or "*No text*" changes.append(f"**Old Content:**\n{old_content}") changes.append(f"**New Content:**\n{new_content}") if before.pinned != after.pinned: status = "📌 Pinned" if after.pinned else "Unpinned" changes.append(f"**Pin Status:** {status}") if len(before.embeds) != len(after.embeds): changes.append(f"**Embeds:** {len(before.embeds)} → {len(after.embeds)}") if len(before.attachments) != len(after.attachments): changes.append(f"**Attachments:** {len(before.attachments)} → {len(after.attachments)}") return changes async def _add_compact_fields( self, embed: discord.Embed, event_name: str, args: List[Any], kwargs: Dict[str, Any] ) -> None: """Add compact field information to embed.""" summary = [] for arg in args: summary.append(await self._format_object_compact(arg)) for key, value in kwargs.items(): summary.append(f"{key}: {await self._format_object_compact(value)}") if summary: embed.description = "\n".join(summary)[:4096] async def _add_json_fields( self, embed: discord.Embed, event_name: str, args: List[Any], kwargs: Dict[str, Any] ) -> None: """Add JSON-formatted data to embed.""" import json data = { "args": [await self._serialize_object(arg) for arg in args], "kwargs": {k: await self._serialize_object(v) for k, v in kwargs.items()}, } json_str = json.dumps(data, indent=2) if len(json_str) > 4000: json_str = json_str[:4000] + "\n...truncated" embed.description = f"```json\n{json_str}\n```" async def _format_object(self, obj: Any) -> str: """Format an object into a beautiful, detailed string.""" if isinstance(obj, discord.User): created = f"" if obj.created_at else "Unknown" bot_badge = "🤖" if obj.bot else "👤" return ( f"{bot_badge} **User:** {obj.mention} (`{obj.id}`)\n" f"**Username:** {obj.name}\n" f"**Display Name:** {obj.display_name}\n" f"**Bot:** {'Yes' if obj.bot else 'No'}\n" f"**Created:** {created}" ) elif isinstance(obj, discord.Member): roles = ", ".join(r.mention for r in obj.roles[1:4]) or "None" if len(obj.roles) > 4: roles += f" *+{len(obj.roles) - 4} more*" joined = f"" if obj.joined_at else "Unknown" created = f"" if obj.created_at else "Unknown" status_emoji = { discord.Status.online: "🟢", discord.Status.idle: "🟡", discord.Status.dnd: "🔴", discord.Status.offline: "⚫", } return ( f"**Member:** {obj.mention} (`{obj.id}`)\n" f"**Display Name:** {obj.display_name}\n" f"**Username:** {obj.name}\n" f"**Nickname:** {obj.nick or '*None*'}\n" f"**Status:** {status_emoji.get(obj.status, '⚫')} {obj.status.name.title()}\n" f"**Roles ({len(obj.roles) - 1}):** {roles}\n" f"**Joined Server:** {joined}\n" f"**Account Created:** {created}\n" f"**Top Role:** {obj.top_role.mention if obj.top_role.name != '@everyone' else '*None*'}" ) elif isinstance(obj, discord.Guild): created = f"" if obj.created_at else "Unknown" features = ", ".join(f"`{f}`" for f in list(obj.features)[:5]) if obj.features else "*None*" if len(obj.features) > 5: features += f" *+{len(obj.features) - 5} more*" boost_level = f"{'⭐' * obj.premium_tier} Level {obj.premium_tier}" if obj.premium_tier else "No boosts" return ( f"🏰 **Guild:** {obj.name} (`{obj.id}`)\n" f"**Owner:** <@{obj.owner_id}>\n" f"**Members:** {obj.member_count:,} total\n" f"**Channels:** {len(obj.channels)} ({len(obj.text_channels)} text, {len(obj.voice_channels)} voice)\n" f"**Roles:** {len(obj.roles)}\n" f"**Boost Status:** {boost_level} ({obj.premium_subscription_count or 0} boosts)\n" f"**Created:** {created}\n" f"**Features:** {features}" ) elif isinstance(obj, discord.TextChannel): perms_msg = "🔒 Private" if obj.overwrites else "🌐 Public" slowmode = f"{obj.slowmode_delay}s" if obj.slowmode_delay else "None" created = f"" if obj.created_at else "Unknown" return ( f"💬 **Channel:** {obj.mention} (`{obj.id}`)\n" f"**Name:** #{obj.name}\n" f"**Category:** {obj.category.name if obj.category else '*None*'}\n" f"**Privacy:** {perms_msg}\n" f"**Slowmode:** {slowmode}\n" f"**Position:** {obj.position}\n" f"**NSFW:** {'Yes ⚠️' if obj.nsfw else 'No'}\n" f"**Created:** {created}" ) elif isinstance(obj, discord.VoiceChannel): limit = f"{obj.user_limit}" if obj.user_limit else "Unlimited ∞" bitrate = f"{obj.bitrate // 1000}kbps" created = f"" if obj.created_at else "Unknown" return ( f"🔊 **Voice Channel:** {obj.name} (`{obj.id}`)\n" f"**Category:** {obj.category.name if obj.category else '*None*'}\n" f"**User Limit:** {limit}\n" f"**Bitrate:** {bitrate}\n" f"**Position:** {obj.position}\n" f"**Region:** {obj.rtc_region or 'Automatic'}\n" f"**Created:** {created}" ) elif isinstance(obj, discord.Role): created = f"" if obj.created_at else "Unknown" perms = obj.permissions perm_list = [] if perms.administrator: perm_list.append("Administrator 👑") if perms.manage_guild: perm_list.append("Manage Server") if perms.manage_roles: perm_list.append("Manage Roles") if perms.manage_channels: perm_list.append("Manage Channels") key_perms = ", ".join(perm_list[:3]) if perm_list else "*No special permissions*" if len(perm_list) > 3: key_perms += f" *+{len(perm_list) - 3} more*" return ( f"**Role:** {obj.mention} (`{obj.id}`)\n" f"**Name:** {obj.name}\n" f"**Color:** {obj.color} (`#{obj.color.value:06X}`)\n" f"**Position:** {obj.position}\n" f"**Hoisted:** {'Yes 📌' if obj.hoist else 'No'}\n" f"**Mentionable:** {'Yes @' if obj.mentionable else 'No'}\n" f"**Members:** {len(obj.members)}\n" f"**Key Permissions:** {key_perms}\n" f"**Created:** {created}" ) elif isinstance(obj, discord.Message): content = obj.content[:150] + "..." if len(obj.content) > 150 else obj.content or "*No text content*" # Format timestamp created = f"" # Add attachment info with icons attachment_info = "" if obj.attachments: att_types = [] for att in obj.attachments: if att.content_type: if att.content_type.startswith("image/"): if att.content_type == "image/gif": att_types.append("🎞️ GIF") else: att_types.append("🖼️ Image") elif att.content_type.startswith("video/"): att_types.append("🎬 Video") elif att.content_type.startswith("audio/"): att_types.append("🎵 Audio") else: att_types.append("📎 File") else: att_types.append("📎 File") attachment_info = f"\n**Attachments ({len(obj.attachments)}):** {', '.join(att_types)}" if obj.stickers: sticker_names = ", ".join(s.name for s in obj.stickers) attachment_info += f"\n**Stickers:** {sticker_names}" # Add embeds/reactions extras = [] if obj.embeds: extras.append(f"{len(obj.embeds)} embed(s)") if obj.reactions: extras.append(f"{len(obj.reactions)} reaction(s)") if obj.mentions: extras.append(f"{len(obj.mentions)} mention(s)") if obj.reference: extras.append("Reply") extras_str = f"\n**Extras:** {', '.join(extras)}" if extras else "" return ( f"📨 **Author:** {obj.author.mention} ({obj.author.name})\n" f"**Channel:** {obj.channel.mention if hasattr(obj.channel, 'mention') else obj.channel}\n" f"**Sent:** {created}\n" f"**Content:** {content}{attachment_info}{extras_str}\n" f"**Message ID:** `{obj.id}`\n" f"**[Jump to Message]({obj.jump_url})**" ) elif isinstance(obj, discord.Emoji): return f"**Emoji:** {obj} (`{obj.id}`)\n**Name:** {obj.name}\n**Animated:** {obj.animated}" elif isinstance(obj, discord.Invite): return ( f"**Code:** {obj.code}\n" f"**Channel:** {obj.channel}\n" f"**Inviter:** {obj.inviter or 'Unknown'}\n" f"**Uses:** {obj.uses or 0}/{obj.max_uses or '∞'}" ) elif isinstance(obj, discord.Integration): return f"**Name:** {obj.name} (`{obj.id}`)\n**Type:** {obj.type}\n**Enabled:** {obj.enabled}" elif isinstance(obj, discord.Thread): return ( f"**Thread:** {obj.mention} (`{obj.id}`)\n" f"**Parent:** {obj.parent.mention if obj.parent else 'Unknown'}\n" f"**Archived:** {obj.archived}" ) elif isinstance(obj, discord.StageInstance): return f"**Topic:** {obj.topic}\n**Channel:** <#{obj.channel_id}>" elif isinstance(obj, discord.ScheduledEvent): return ( f"**Event:** {obj.name}\n" f"**Location:** {obj.location or 'Unknown'}\n" f"**Start:** {obj.start_time.strftime('%Y-%m-%d %H:%M')}" ) elif isinstance(obj, discord.AutoModRule): return f"**Rule:** {obj.name} (`{obj.id}`)\n**Enabled:** {obj.enabled}\n**Actions:** {len(obj.actions)}" elif isinstance(obj, discord.AutoModAction): return f"**Action:** {obj.type}\n**Rule:** <@{obj.rule_id}>" elif isinstance(obj, discord.Interaction): return ( f"**User:** {obj.user.mention}\n" f"**Type:** {obj.type}\n" f"**Command:** {obj.command.name if obj.command else 'Unknown'}" ) elif isinstance(obj, discord.VoiceState): channel = obj.channel.mention if obj.channel else "None" return ( f"**Channel:** {channel}\n" f"**Muted:** {obj.mute} | **Deafened:** {obj.deaf}\n" f"**Streaming:** {obj.self_stream} | **Video:** {obj.self_video}" ) else: return f"`{type(obj).__name__}`: {str(obj)[:200]}" async def _format_object_compact(self, obj: Any) -> str: """Format an object into a compact string.""" if isinstance(obj, (discord.User, discord.Member)): return f"{obj.mention} ({obj.id})" elif isinstance(obj, discord.Guild): return f"{obj.name} ({obj.id})" elif isinstance(obj, (discord.TextChannel, discord.VoiceChannel)): return f"#{obj.name} ({obj.id})" elif isinstance(obj, discord.Role): return f"{obj.mention}" elif isinstance(obj, discord.Message): return f"Message {obj.id} by {obj.author}" else: return str(obj)[:100] async def _serialize_object(self, obj: Any) -> Any: """Serialize an object for JSON output.""" if isinstance(obj, (discord.User, discord.Member, discord.Guild, discord.Role)): return {"id": obj.id, "name": getattr(obj, "name", str(obj)), "type": type(obj).__name__} elif isinstance(obj, (discord.TextChannel, discord.VoiceChannel)): return {"id": obj.id, "name": obj.name, "type": type(obj).__name__} elif isinstance(obj, discord.Message): return { "id": obj.id, "author_id": obj.author.id, "content": obj.content[:500], "channel_id": obj.channel.id, } elif hasattr(obj, "id"): return {"id": obj.id, "type": type(obj).__name__} else: return str(obj)[:200] # ═══════════════════════════════════════════════════════════════════════ # Commands # ═══════════════════════════════════════════════════════════════════════ @commands.group(name="rlog", aliases=["rubylog"]) @commands.guild_only() @commands.admin_or_permissions(manage_guild=True) async def rlog(self, ctx: commands.Context) -> None: """RubyLogging - Ultimate Discord event logging system.""" if ctx.invoked_subcommand is None: await ctx.send_help(ctx.command) @rlog.command(name="channel") async def rlog_channel( self, ctx: commands.Context, channel: discord.TextChannel ) -> None: """Set the logging channel.""" await self.config.guild(ctx.guild).log_channel.set(channel.id) await ctx.send(f"✅ Logging channel set to {channel.mention}") @rlog.command(name="enable") async def rlog_enable(self, ctx: commands.Context, *events: str) -> None: """Enable specific events for logging. Use `all` to enable all events in a category. Example: `[p]rlog enable message_delete member_join` Example: `[p]rlog enable all:members` to enable all member events """ if not events: await ctx.send("❌ Please specify at least one event or category.") return guild_config = self.config.guild(ctx.guild) enabled = await guild_config.enabled_events() added = [] for event in events: if event.startswith("all:"): # Enable all events in category category = event.split(":", 1)[1] if category in EVENTS: for cat_event in EVENTS[category]: if cat_event not in enabled: enabled.append(cat_event) added.append(cat_event) else: await ctx.send(f"❌ Unknown category: `{category}`") return else: # Enable specific event found = False for category, cat_events in EVENTS.items(): if event in cat_events: if event not in enabled: enabled.append(event) added.append(event) found = True break if not found: await ctx.send(f"❌ Unknown event: `{event}`") return await guild_config.enabled_events.set(enabled) if added: await ctx.send(f"✅ Enabled {len(added)} event(s): {humanize_list([f'`{e}`' for e in added])}") else: await ctx.send("ℹ️ All specified events were already enabled.") @rlog.command(name="disable") async def rlog_disable(self, ctx: commands.Context, *events: str) -> None: """Disable specific events. Example: `[p]rlog disable message_delete` Example: `[p]rlog disable all:messages` to disable all message events """ if not events: await ctx.send("❌ Please specify at least one event or category.") return guild_config = self.config.guild(ctx.guild) enabled = await guild_config.enabled_events() removed = [] for event in events: if event.startswith("all:"): # Disable all events in category category = event.split(":", 1)[1] if category in EVENTS: for cat_event in EVENTS[category]: if cat_event in enabled: enabled.remove(cat_event) removed.append(cat_event) else: await ctx.send(f"❌ Unknown category: `{category}`") return else: # Disable specific event if event in enabled: enabled.remove(event) removed.append(event) await guild_config.enabled_events.set(enabled) if removed: await ctx.send(f"✅ Disabled {len(removed)} event(s): {humanize_list([f'`{e}`' for e in removed])}") else: await ctx.send("ℹ️ None of the specified events were enabled.") @rlog.command(name="list") async def rlog_list(self, ctx: commands.Context, category: Optional[str] = None) -> None: """List all available events, optionally filtered by category.""" if category and category not in EVENTS: await ctx.send(f"❌ Unknown category: `{category}`\nAvailable: {humanize_list([f'`{c}`' for c in EVENTS.keys()])}") return enabled = await self.config.guild(ctx.guild).enabled_events() output = [] categories = {category: EVENTS[category]} if category else EVENTS for cat, events in categories.items(): output.append(f"\n**{cat.upper()}** ({len(events)} events):") for event in sorted(events): status = "✅" if event in enabled else "⬜" output.append(f" {status} `{event}`") for page in pagify("\n".join(output), delims=["\n"], page_length=1900): await ctx.send(page) @rlog.command(name="categories") async def rlog_categories(self, ctx: commands.Context) -> None: """Show all event categories and their event counts.""" enabled = await self.config.guild(ctx.guild).enabled_events() lines = ["**📋 Event Categories**\n"] for category, events in EVENTS.items(): enabled_count = sum(1 for e in events if e in enabled) total = len(events) status = "🟢" if enabled_count > 0 else "⬜" lines.append(f"{status} **{category.title()}**: {enabled_count}/{total} events enabled") await ctx.send("\n".join(lines)) @rlog.command(name="format") async def rlog_format(self, ctx: commands.Context, format_type: str) -> None: """Set the log format: detailed, compact, or json.""" format_type = format_type.lower() if format_type not in ["detailed", "compact", "json"]: await ctx.send("❌ Invalid format. Choose: `detailed`, `compact`, or `json`") return await self.config.guild(ctx.guild).format.set(format_type) await ctx.send(f"✅ Log format set to **{format_type}**") @rlog.command(name="ignorebots") async def rlog_ignorebots(self, ctx: commands.Context, enabled: bool) -> None: """Toggle ignoring events from bots.""" await self.config.guild(ctx.guild).ignore_bots.set(enabled) status = "enabled" if enabled else "disabled" await ctx.send(f"✅ Bot filtering **{status}**") @rlog.command(name="ignoreuser") async def rlog_ignoreuser( self, ctx: commands.Context, user: discord.User, action: str = "add" ) -> None: """Add or remove a user from the ignore list.""" guild_config = self.config.guild(ctx.guild) ignore_list = await guild_config.ignore_users() if action.lower() == "add": if user.id not in ignore_list: ignore_list.append(user.id) await guild_config.ignore_users.set(ignore_list) await ctx.send(f"✅ Now ignoring events from {user.mention}") else: await ctx.send(f"ℹ️ {user.mention} is already being ignored.") elif action.lower() == "remove": if user.id in ignore_list: ignore_list.remove(user.id) await guild_config.ignore_users.set(ignore_list) await ctx.send(f"✅ No longer ignoring events from {user.mention}") else: await ctx.send(f"ℹ️ {user.mention} was not being ignored.") else: await ctx.send("❌ Action must be `add` or `remove`") @rlog.command(name="ignorechannel") async def rlog_ignorechannel( self, ctx: commands.Context, channel: discord.TextChannel, action: str = "add" ) -> None: """Add or remove a channel from the ignore list.""" guild_config = self.config.guild(ctx.guild) ignore_list = await guild_config.ignore_channels() if action.lower() == "add": if channel.id not in ignore_list: ignore_list.append(channel.id) await guild_config.ignore_channels.set(ignore_list) await ctx.send(f"✅ Now ignoring events from {channel.mention}") else: await ctx.send(f"ℹ️ {channel.mention} is already being ignored.") elif action.lower() == "remove": if channel.id in ignore_list: ignore_list.remove(channel.id) await guild_config.ignore_channels.set(ignore_list) await ctx.send(f"✅ No longer ignoring events from {channel.mention}") else: await ctx.send(f"ℹ️ {channel.mention} was not being ignored.") else: await ctx.send("❌ Action must be `add` or `remove`") @rlog.command(name="settings") async def rlog_settings(self, ctx: commands.Context) -> None: """Show current logging configuration.""" config = self.config.guild(ctx.guild) channel_id = await config.log_channel() channel = ctx.guild.get_channel(channel_id) if channel_id else None enabled_events = await config.enabled_events() format_type = await config.format() ignore_bots = await config.ignore_bots() ignore_users = await config.ignore_users() ignore_channels = await config.ignore_channels() # Attachment settings log_attachments = await config.log_attachments() log_stickers = await config.log_stickers() show_previews = await config.show_attachment_previews() track_deleted = await config.track_deleted_attachments() max_previews = await config.max_preview_attachments() embed = discord.Embed( title="🔧 RubyLogging Settings", color=discord.Color.blue(), ) embed.add_field( name="Log Channel", value=channel.mention if channel else "❌ Not set", inline=False, ) embed.add_field( name="Enabled Events", value=f"{len(enabled_events)} events" if enabled_events else "None", inline=True, ) embed.add_field(name="Format", value=format_type.title(), inline=True) embed.add_field(name="Ignore Bots", value="✅" if ignore_bots else "❌", inline=True) embed.add_field( name="Ignored Users", value=f"{len(ignore_users)} users" if ignore_users else "None", inline=True, ) embed.add_field( name="Ignored Channels", value=f"{len(ignore_channels)} channels" if ignore_channels else "None", inline=True, ) # Attachment settings reupload = await config.reupload_attachments() attachment_status = ( f"{'✅' if log_attachments else '❌'} Logging\n" f"{'✅' if log_stickers else '❌'} Stickers\n" f"{'✅' if show_previews else '❌'} Previews\n" f"{'✅' if track_deleted else '❌'} Track Deleted\n" f"{'✅' if reupload else '❌'} Re-upload\n" f"📊 Max: {max_previews}\n" f"💾 Cached: {len(self._attachment_cache)}" ) embed.add_field( name="📎 Attachments", value=attachment_status, inline=True, ) # Event breakdown by category category_stats = [] for category, events in EVENTS.items(): enabled_count = sum(1 for e in events if e in enabled_events) if enabled_count > 0: category_stats.append(f"**{category.title()}**: {enabled_count}/{len(events)}") if category_stats: embed.add_field( name="Category Breakdown", value="\n".join(category_stats), inline=False, ) await ctx.send(embed=embed) @rlog.command(name="quickstart") async def rlog_quickstart( self, ctx: commands.Context, channel: discord.TextChannel ) -> None: """Quick setup: enable common events and set log channel.""" # Common events to enable common_events = [ "member_join", "member_remove", "member_ban", "member_unban", "message_delete", "message_edit", "guild_channel_create", "guild_channel_delete", "guild_role_create", "guild_role_delete", "voice_state_update", ] guild_config = self.config.guild(ctx.guild) await guild_config.log_channel.set(channel.id) await guild_config.enabled_events.set(common_events) await guild_config.ignore_bots.set(True) # Enable attachment logging by default await guild_config.log_attachments.set(True) await guild_config.log_stickers.set(True) await guild_config.show_attachment_previews.set(True) await guild_config.track_deleted_attachments.set(True) await ctx.send( f"✅ **Quick setup complete!**\n" f"• Log channel: {channel.mention}\n" f"• Enabled {len(common_events)} common events\n" f"• Bot events ignored\n" f"• Attachment logging enabled (images, GIFs, videos)\n" f"• Deleted attachment tracking enabled\n\n" f"Use `{ctx.prefix}rlog list` to see all events and customize further.\n" f"Use `{ctx.prefix}rlog attachments` to configure media logging." ) @rlog.group(name="attachments", aliases=["attach", "files"]) async def rlog_attachments(self, ctx: commands.Context) -> None: """Attachment and media logging settings.""" if ctx.invoked_subcommand is None: config = self.config.guild(ctx.guild) log_attachments = await config.log_attachments() log_stickers = await config.log_stickers() show_previews = await config.show_attachment_previews() track_deleted = await config.track_deleted_attachments() max_previews = await config.max_preview_attachments() reupload = await config.reupload_attachments() status = ( f"**📎 Attachment Logging**\n" f"{'✅' if log_attachments else '❌'} Log Attachments: {'On' if log_attachments else 'Off'}\n" f"{'✅' if log_stickers else '❌'} Log Stickers: {'On' if log_stickers else 'Off'}\n" f"{'✅' if show_previews else '❌'} Show Previews: {'On' if show_previews else 'Off'}\n" f"{'✅' if track_deleted else '❌'} Track Deleted: {'On' if track_deleted else 'Off'}\n" f"{'✅' if reupload else '❌'} Re-upload: {'On' if reupload else 'Off'}\n" f"📊 Max Previews: {max_previews}\n\n" f"**Cache Status:** {len(self._attachment_cache)} messages cached" ) await ctx.send(status) @rlog_attachments.command(name="toggle") async def rlog_attach_toggle(self, ctx: commands.Context) -> None: """Toggle attachment logging on/off.""" current = await self.config.guild(ctx.guild).log_attachments() new_val = not current await self.config.guild(ctx.guild).log_attachments.set(new_val) status = "enabled" if new_val else "disabled" await ctx.send(f"✅ Attachment logging **{status}**") @rlog_attachments.command(name="stickers") async def rlog_attach_stickers(self, ctx: commands.Context) -> None: """Toggle sticker logging on/off.""" current = await self.config.guild(ctx.guild).log_stickers() new_val = not current await self.config.guild(ctx.guild).log_stickers.set(new_val) status = "enabled" if new_val else "disabled" await ctx.send(f"✅ Sticker logging **{status}**") @rlog_attachments.command(name="previews") async def rlog_attach_previews(self, ctx: commands.Context) -> None: """Toggle attachment preview embeds on/off.""" current = await self.config.guild(ctx.guild).show_attachment_previews() new_val = not current await self.config.guild(ctx.guild).show_attachment_previews.set(new_val) status = "enabled" if new_val else "disabled" await ctx.send( f"✅ Attachment previews **{status}**\n" f"Images/GIFs will {'be shown' if new_val else 'not be shown'} in log embeds." ) @rlog_attachments.command(name="tracking") async def rlog_attach_tracking(self, ctx: commands.Context) -> None: """Toggle deleted attachment tracking on/off. When enabled, the bot caches attachments from all messages so they can be logged when messages are deleted. Slight memory overhead. """ current = await self.config.guild(ctx.guild).track_deleted_attachments() new_val = not current await self.config.guild(ctx.guild).track_deleted_attachments.set(new_val) status = "enabled" if new_val else "disabled" if new_val: await ctx.send( f"✅ Deleted attachment tracking **{status}**\n" f"The bot will now cache attachments to log them when messages are deleted.\n" f"**Note:** Only attachments from messages sent *after* enabling this will be tracked." ) else: # Clear cache when disabled self._attachment_cache.clear() await ctx.send( f"✅ Deleted attachment tracking **{status}**\n" f"Cleared {len(self._attachment_cache)} cached attachments." ) @rlog_attachments.command(name="maxpreviews") async def rlog_attach_maxpreviews(self, ctx: commands.Context, count: int) -> None: """Set maximum number of attachment previews to show (1-10).""" count = max(1, min(10, count)) await self.config.guild(ctx.guild).max_preview_attachments.set(count) await ctx.send(f"✅ Max attachment previews set to **{count}**") @rlog_attachments.command(name="reupload") async def rlog_attach_reupload(self, ctx: commands.Context) -> None: """Toggle re-uploading attachments to preserve them after deletion. When enabled, deleted images/GIFs are downloaded and re-uploaded to the log channel so they remain visible forever (not just proxy URLs that expire). **Note:** Uses bandwidth and storage. Attachments become permanent in log channel. """ current = await self.config.guild(ctx.guild).reupload_attachments() new_val = not current await self.config.guild(ctx.guild).reupload_attachments.set(new_val) status = "enabled" if new_val else "disabled" if new_val: await ctx.send( f"✅ Attachment re-upload **{status}**\n" f"Deleted images/GIFs will be downloaded and re-uploaded to preserve them permanently.\n" f"⚠️ **Note:** This uses bandwidth and the files become permanent in the log channel." ) else: await ctx.send( f"✅ Attachment re-upload **{status}**\n" f"Deleted attachments will only show proxy URLs (which may expire)." ) @rlog_attachments.command(name="clearcache") @commands.admin_or_permissions(manage_guild=True) async def rlog_attach_clearcache(self, ctx: commands.Context) -> None: """Clear the attachment cache (admin only).""" count = len(self._attachment_cache) self._attachment_cache.clear() await ctx.send(f"✅ Cleared **{count}** cached attachments from memory.") @rlog.command(name="reset") async def rlog_reset(self, ctx: commands.Context) -> None: """Reset all logging settings to default.""" await self.config.guild(ctx.guild).clear() self._attachment_cache.clear() await ctx.send("✅ All logging settings have been reset.")