Enhance Makefile and update metrics handling in bot

- Added new commands in the Makefile for restarting individual services: `restart-bot`, `restart-prometheus`, and `restart-grafana`.
- Updated Prometheus and Grafana dashboard expressions for better metrics aggregation.
- Removed the `main_with_metrics.py` file and integrated metrics handling directly into the main bot file.
- Refactored middleware to improve metrics tracking and error handling across message and callback processing.
- Optimized metrics recording with enhanced bucket configurations for better performance monitoring.

helper_bot/middlewares/blacklist_middleware.py

@@ -2,6 +2,7 @@ from typing import Dict, Any
 import html
 
 from aiogram import BaseMiddleware, types
+from aiogram.types import TelegramObject, Message, CallbackQuery
 from helper_bot.utils.base_dependency_factory import get_global_instance
 from logs.custom_logger import logger
 
@@ -10,17 +11,38 @@ BotDB = bdf.get_db()
 
 
 class BlacklistMiddleware(BaseMiddleware):
-    async def __call__(self, handler, event: types.Message, data: Dict[str, Any]) -> Any:
-        logger.info(f'Вызов BlacklistMiddleware для пользователя {event.from_user.username}')
+    async def __call__(self, handler, event: TelegramObject, data: Dict[str, Any]) -> Any:
+        # Проверяем тип события и получаем пользователя
+        user = None
+        if isinstance(event, Message):
+            user = event.from_user
+        elif isinstance(event, CallbackQuery):
+            user = event.from_user
+        
+        # Если это не сообщение или callback, пропускаем проверку
+        if not user:
+            return await handler(event, data)
+        
+        logger.info(f'Вызов BlacklistMiddleware для пользователя {user.username}')
+        
         # Используем асинхронную версию для предотвращения блокировки
-        if await BotDB.check_user_in_blacklist_async(user_id=event.from_user.id):
-            logger.info(f'BlacklistMiddleware результат для пользователя: {event.from_user.username} заблокирован!')
-            user_info = await BotDB.get_blacklist_users_by_id_async(event.from_user.id)
+        if await BotDB.check_user_in_blacklist_async(user_id=user.id):
+            logger.info(f'BlacklistMiddleware результат для пользователя: {user.username} заблокирован!')
+            user_info = await BotDB.get_blacklist_users_by_id_async(user.id)
             # Экранируем потенциально проблемные символы
             reason = html.escape(str(user_info[2])) if user_info[2] else "Не указана"
             date_unban = html.escape(str(user_info[3])) if user_info[3] else "Не указана"
-            await event.answer(
-                f"<b>Ты заблокирован.</b>\n<b>Причина блокировки:</b> {reason}\n<b>Дата разбана:</b> {date_unban}")
+            
+            # Отправляем сообщение в зависимости от типа события
+            if isinstance(event, Message):
+                await event.answer(
+                    f"<b>Ты заблокирован.</b>\n<b>Причина блокировки:</b> {reason}\n<b>Дата разбана:</b> {date_unban}")
+            elif isinstance(event, CallbackQuery):
+                await event.answer(
+                    f"<b>Ты заблокирован.</b>\n<b>Причина блокировки:</b> {reason}\n<b>Дата разбана:</b> {date_unban}",
+                    show_alert=True)
+            
             return False
-        logger.info(f'BlacklistMiddleware результат для пользователя: {event.from_user.username} доступ разрешен')
+        
+        logger.info(f'BlacklistMiddleware результат для пользователя: {user.username} доступ разрешен')
         return await handler(event, data)

helper_bot/middlewares/metrics_middleware.py

@@ -8,7 +8,7 @@ from aiogram import BaseMiddleware
 from aiogram.types import TelegramObject, Message, CallbackQuery
 from aiogram.enums import ChatType
 import time
-from ..utils.metrics import metrics, track_middleware
+from ..utils.metrics import metrics
 
 
 class MetricsMiddleware(BaseMiddleware):
@@ -22,50 +22,57 @@ class MetricsMiddleware(BaseMiddleware):
     ) -> Any:
         """Process event and collect metrics."""
         
-        async with track_middleware("metrics_middleware"):
-            # Record message processing
-            if isinstance(event, Message):
-                await self._record_message_metrics(event, data)
-            elif isinstance(event, CallbackQuery):
-                await self._record_callback_metrics(event, data)
+        # Record basic event metrics
+        if isinstance(event, Message):
+            await self._record_message_metrics(event)
+        elif isinstance(event, CallbackQuery):
+            await self._record_callback_metrics(event)
+        
+        # Execute handler with timing
+        start_time = time.time()
+        try:
+            result = await handler(event, data)
+            duration = time.time() - start_time
             
-            # Execute handler and collect timing
-            start_time = time.time()
-            try:
-                result = await handler(event, data)
-                duration = time.time() - start_time
-                
-                # Record successful execution
-                handler_name = handler.__name__ if hasattr(handler, '__name__') else "unknown"
-                metrics.record_method_duration(
-                    handler_name,
-                    duration,
-                    "handler",
-                    "success"
-                )
-                
-                return result
-                
-            except Exception as e:
-                duration = time.time() - start_time
-                
-                # Record error and timing
-                handler_name = handler.__name__ if hasattr(handler, '__name__') else "unknown"
-                metrics.record_method_duration(
-                    handler_name,
-                    duration,
-                    "handler",
-                    "error"
-                )
-                metrics.record_error(
-                    type(e).__name__,
-                    "handler",
-                    handler_name
-                )
-                raise
+            # Record successful execution
+            handler_name = self._get_handler_name(handler)
+            metrics.record_method_duration(
+                handler_name,
+                duration,
+                "handler",
+                "success"
+            )
+            
+            return result
+            
+        except Exception as e:
+            duration = time.time() - start_time
+            
+            # Record error and timing
+            handler_name = self._get_handler_name(handler)
+            metrics.record_method_duration(
+                handler_name,
+                duration,
+                "handler",
+                "error"
+            )
+            metrics.record_error(
+                type(e).__name__,
+                "handler",
+                handler_name
+            )
+            raise
     
-    async def _record_message_metrics(self, message: Message, data: Dict[str, Any]):
-        """Record metrics for message processing."""
+    def _get_handler_name(self, handler: Callable) -> str:
+        """Extract handler name efficiently."""
+        if hasattr(handler, '__name__'):
+            return handler.__name__
+        elif hasattr(handler, '__qualname__'):
+            return handler.__qualname__
+        return "unknown"
+    
+    async def _record_message_metrics(self, message: Message):
+        """Record message metrics efficiently."""
         # Determine message type
         message_type = "text"
         if message.photo:
@@ -92,41 +99,25 @@ class MetricsMiddleware(BaseMiddleware):
         elif message.chat.type == ChatType.CHANNEL:
             chat_type = "channel"
         
-        # Determine handler type
-        handler_type = "unknown"
-        if message.text and message.text.startswith('/'):
-            handler_type = "command"
-            # Record command specifically
-            command = message.text.split()[0][1:]  # Remove '/' and get command name
-            metrics.record_command(
-                command,
-                "message_handler",
-                "user" if message.from_user else "unknown"
-            )
-        
         # Record message processing
-        metrics.record_message(message_type, chat_type, handler_type)
-    
-    async def _record_callback_metrics(self, callback: CallbackQuery, data: Dict[str, Any]):
-        """Record metrics for callback query processing."""
-        # Record callback processing
-        metrics.record_message(
-            "callback_query",
-            "callback",
-            "callback_handler"
-        )
+        metrics.record_message(message_type, chat_type, "message_handler")
+        
+        # Record command if applicable
+        if message.text and message.text.startswith('/'):
+            command = message.text.split()[0][1:]  # Remove '/' and get command name
+            user_type = "user" if message.from_user else "unknown"
+            metrics.record_command(command, "message_handler", user_type)
+    
+    async def _record_callback_metrics(self, callback: CallbackQuery):
+        """Record callback metrics efficiently."""
+        metrics.record_message("callback_query", "callback", "callback_handler")
         
-        # Record callback command if available
         if callback.data:
-            # Extract command from callback data (assuming format like "command:param")
             parts = callback.data.split(':', 1)
             if parts:
                 command = parts[0]
-                metrics.record_command(
-                    command,
-                    "callback_handler",
-                    "user" if callback.from_user else "unknown"
-                )
+                user_type = "user" if callback.from_user else "unknown"
+                metrics.record_command(command, "callback_handler", user_type)
 
 
 class DatabaseMetricsMiddleware(BaseMiddleware):