Refactor Docker and configuration files for improved structure and functionality

- Updated `.dockerignore` to include additional development and temporary files, enhancing build efficiency.
- Modified `.gitignore` to remove unnecessary entries and streamline ignored files.
- Enhanced `docker-compose.yml` with health checks, resource limits, and improved environment variable handling for better service management.
- Refactored `Dockerfile.bot` to utilize a multi-stage build for optimized image size and security.
- Improved `Makefile` with new commands for deployment, migration, and backup, along with enhanced help documentation.
- Updated `requirements.txt` to include new dependencies for environment variable management.
- Refactored metrics handling in the bot to ensure proper initialization and collection.

helper_bot/handlers/admin/admin_handlers.py

@@ -307,3 +307,44 @@ async def cancel_ban_process(
         await return_to_admin_menu(message, state)
     except Exception as e:
         await handle_admin_error(message, e, state, "cancel_ban_process")
+
+
+@admin_router.message(Command("test_metrics"))
+async def test_metrics_handler(
+    message: types.Message,
+    bot_db: MagicData("bot_db")
+):
+    """Тестовый хендлер для проверки метрик"""
+    from helper_bot.utils.metrics import metrics
+    
+    try:
+        # Принудительно записываем тестовые метрики
+        metrics.record_command("test_metrics", "admin_handler", "admin", "success")
+        metrics.record_message("text", "private", "admin_handler")
+        metrics.record_error("TestError", "admin_handler", "test_metrics_handler")
+        
+        # Проверяем активных пользователей
+        if hasattr(bot_db, 'connect') and hasattr(bot_db, 'cursor'):
+            active_users_query = """
+                SELECT COUNT(DISTINCT user_id) as active_users
+                FROM our_users 
+                WHERE date_changed > datetime('now', '-1 day')
+            """
+            try:
+                bot_db.connect()
+                bot_db.cursor.execute(active_users_query)
+                result = bot_db.cursor.fetchone()
+                active_users = result[0] if result else 0
+            finally:
+                bot_db.close()
+        else:
+            active_users = "N/A"
+        
+        await message.answer(
+            f"✅ Тестовые метрики записаны\n"
+            f"📊 Активных пользователей: {active_users}\n"
+            f"🔧 Проверьте Grafana дашборд"
+        )
+        
+    except Exception as e:
+        await message.answer(f"❌ Ошибка тестирования метрик: {e}")

helper_bot/main.py

@@ -25,6 +25,12 @@ async def start_bot(bdf):
     dp.update.outer_middleware(MetricsMiddleware())
     dp.update.outer_middleware(BlacklistMiddleware())
     
+    # Добавляем middleware напрямую к роутерам для тестирования
+    admin_router.message.middleware(MetricsMiddleware())
+    private_router.message.middleware(MetricsMiddleware())
+    callback_router.callback_query.middleware(MetricsMiddleware())
+    group_router.message.middleware(MetricsMiddleware())
+    
     dp.include_routers(admin_router, private_router, callback_router, group_router)
     await bot.delete_webhook(drop_pending_updates=True)
     await dp.start_polling(bot, skip_updates=True)

helper_bot/middlewares/metrics_middleware.py

@@ -8,12 +8,17 @@ from aiogram import BaseMiddleware
 from aiogram.types import TelegramObject, Message, CallbackQuery
 from aiogram.enums import ChatType
 import time
+import logging
 from ..utils.metrics import metrics
 
 
 class MetricsMiddleware(BaseMiddleware):
     """Middleware for automatic metrics collection in aiogram handlers."""
     
+    def __init__(self):
+        super().__init__()
+        self.logger = logging.getLogger(__name__)
+    
     async def __call__(
         self,
         handler: Callable[[TelegramObject, Dict[str, Any]], Awaitable[Any]],
@@ -22,11 +27,33 @@ class MetricsMiddleware(BaseMiddleware):
     ) -> Any:
         """Process event and collect metrics."""
         
-        # Record basic event metrics
+        # Добавляем логирование для диагностики
+        self.logger.info(f"📊 MetricsMiddleware called for event type: {type(event).__name__}")
+        
+        # Extract command info before execution
+        command_info = None
         if isinstance(event, Message):
+            self.logger.info(f"📊 Processing Message event")
             await self._record_message_metrics(event)
+            if event.text and event.text.startswith('/'):
+                command_info = {
+                    'command': event.text.split()[0][1:],  # Remove '/' and get command name
+                    'user_type': "user" if event.from_user else "unknown",
+                    'handler_type': "message_handler"
+                }
         elif isinstance(event, CallbackQuery):
+            self.logger.info(f"📊 Processing CallbackQuery event")
             await self._record_callback_metrics(event)
+            if event.data:
+                parts = event.data.split(':', 1)
+                if parts:
+                    command_info = {
+                        'command': parts[0],
+                        'user_type': "user" if event.from_user else "unknown",
+                        'handler_type': "callback_handler"
+                    }
+        else:
+            self.logger.info(f"📊 Processing unknown event type: {type(event).__name__}")
         
         # Execute handler with timing
         start_time = time.time()
@@ -36,6 +63,7 @@ class MetricsMiddleware(BaseMiddleware):
             
             # Record successful execution
             handler_name = self._get_handler_name(handler)
+            self.logger.info(f"📊 Recording successful execution: {handler_name}")
             metrics.record_method_duration(
                 handler_name,
                 duration,
@@ -43,6 +71,15 @@ class MetricsMiddleware(BaseMiddleware):
                 "success"
             )
             
+            # Record command with success status if applicable
+            if command_info:
+                metrics.record_command(
+                    command_info['command'],
+                    command_info['handler_type'],
+                    command_info['user_type'],
+                    "success"
+                )
+            
             return result
             
         except Exception as e:
@@ -50,6 +87,7 @@ class MetricsMiddleware(BaseMiddleware):
             
             # Record error and timing
             handler_name = self._get_handler_name(handler)
+            self.logger.error(f"📊 Recording error execution: {handler_name}, error: {type(e).__name__}")
             metrics.record_method_duration(
                 handler_name,
                 duration,
@@ -61,15 +99,39 @@ class MetricsMiddleware(BaseMiddleware):
                 "handler",
                 handler_name
             )
+            
+            # Record command with error status if applicable
+            if command_info:
+                metrics.record_command(
+                    command_info['command'],
+                    command_info['handler_type'],
+                    command_info['user_type'],
+                    "error"
+                )
+            
             raise
     
     def _get_handler_name(self, handler: Callable) -> str:
         """Extract handler name efficiently."""
-        if hasattr(handler, '__name__'):
+        # Проверяем различные способы получения имени хендлера
+        if hasattr(handler, '__name__') and handler.__name__ != '<lambda>':
             return handler.__name__
-        elif hasattr(handler, '__qualname__'):
+        elif hasattr(handler, '__qualname__') and handler.__qualname__ != '<lambda>':
             return handler.__qualname__
-        return "unknown"
+        elif hasattr(handler, 'callback') and hasattr(handler.callback, '__name__'):
+            return handler.callback.__name__
+        elif hasattr(handler, 'view') and hasattr(handler.view, '__name__'):
+            return handler.view.__name__
+        else:
+            # Пытаемся получить имя из строкового представления
+            handler_str = str(handler)
+            if 'function' in handler_str:
+                # Извлекаем имя функции из строки
+                import re
+                match = re.search(r'function\s+(\w+)', handler_str)
+                if match:
+                    return match.group(1)
+            return "unknown"
     
     async def _record_message_metrics(self, message: Message):
         """Record message metrics efficiently."""
@@ -101,23 +163,10 @@ class MetricsMiddleware(BaseMiddleware):
         
         # Record message processing
         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")
-        
-        if callback.data:
-            parts = callback.data.split(':', 1)
-            if parts:
-                command = parts[0]
-                user_type = "user" if callback.from_user else "unknown"
-                metrics.record_command(command, "callback_handler", user_type)
 
 
 class DatabaseMetricsMiddleware(BaseMiddleware):

helper_bot/utils/base_dependency_factory.py

@@ -1,33 +1,61 @@
-import configparser
 import os
 import sys
+from dotenv import load_dotenv
 
 from database.db import BotDB
 
-current_dir = os.getcwd()
-
 
 class BaseDependencyFactory:
     def __init__(self):
-        # Загрузка настроек из settings.ini
-        config_path = os.path.join(sys.path[0], 'settings.ini')
-        self.config = configparser.ConfigParser()
-        self.config.read(config_path)
-        self.settings = {}
-        # Используем абсолютный путь к директории проекта
         project_dir = os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
-        self.database = BotDB(project_dir, 'tg-bot-database.db')
+        env_path = os.path.join(project_dir, '.env')
+        if os.path.exists(env_path):
+            load_dotenv(env_path)
 
-        for section in self.config.sections():
-            self.settings[section] = {}
-            for key in self.config[section]:
-                # Преобразование значений в соответствующий тип
-                if key == 'PREVIEW_LINK':
-                    self.settings[section][key] = self.config.getboolean(section, key)
-                elif key == 'LOGS' or key == 'TEST':
-                    self.settings[section][key] = self.config.getboolean(section, key)
-                else:
-                    self.settings[section][key] = self.config.get(section, key)
+        self.settings = {}
+
+        database_path = os.getenv('DATABASE_PATH', 'database/tg-bot-database.db')
+        if not os.path.isabs(database_path):
+            database_path = os.path.join(project_dir, database_path)
+
+        database_dir = project_dir
+        database_name = database_path.replace(project_dir + '/', '')
+
+        self.database = BotDB(database_dir, database_name)
+
+        self._load_settings_from_env()
+
+    def _load_settings_from_env(self):
+        """Загружает настройки из переменных окружения."""
+        self.settings['Telegram'] = {
+            'bot_token': os.getenv('BOT_TOKEN', ''),
+            'listen_bot_token': os.getenv('LISTEN_BOT_TOKEN', ''),
+            'test_bot_token': os.getenv('TEST_BOT_TOKEN', ''),
+            'preview_link': self._parse_bool(os.getenv('PREVIEW_LINK', 'false')),
+            'main_public': os.getenv('MAIN_PUBLIC', ''),
+            'group_for_posts': self._parse_int(os.getenv('GROUP_FOR_POSTS', '0')),
+            'group_for_message': self._parse_int(os.getenv('GROUP_FOR_MESSAGE', '0')),
+            'group_for_logs': self._parse_int(os.getenv('GROUP_FOR_LOGS', '0')),
+            'important_logs': self._parse_int(os.getenv('IMPORTANT_LOGS', '0')),
+            'archive': self._parse_int(os.getenv('ARCHIVE', '0')),
+            'test_group': self._parse_int(os.getenv('TEST_GROUP', '0'))
+        }
+
+        self.settings['Settings'] = {
+            'logs': self._parse_bool(os.getenv('LOGS', 'false')),
+            'test': self._parse_bool(os.getenv('TEST', 'false'))
+        }
+
+    def _parse_bool(self, value: str) -> bool:
+        """Парсит строковое значение в boolean."""
+        return value.lower() in ('true', '1', 'yes', 'on')
+
+    def _parse_int(self, value: str) -> int:
+        """Парсит строковое значение в integer."""
+        try:
+            return int(value)
+        except (ValueError, TypeError):
+            return 0
 
     def get_settings(self):
         return self.settings
@@ -37,7 +65,6 @@ class BaseDependencyFactory:
         return self.database
 
 
-# Создаем единый экземпляр для всего приложения
 _global_instance = None
 
 def get_global_instance():

helper_bot/utils/config.py

@@ -0,0 +1,91 @@
+"""
+Configuration management for the Telegram bot.
+Supports both environment variables and .env files.
+"""
+
+import os
+from typing import Dict, Any, Optional
+from dotenv import load_dotenv
+
+
+class ConfigManager:
+    """Manages bot configuration with environment variable support."""
+    
+    def __init__(self, env_file: str = ".env"):
+        self.env_file = env_file
+        self._load_env()
+    
+    def _load_env(self):
+        """Load configuration from .env file if exists."""
+        # Load from .env file if exists
+        if os.path.exists(self.env_file):
+            load_dotenv(self.env_file)
+    
+    def get(self, section: str, key: str, default: Any = None) -> str:
+        """Get configuration value with environment variable override."""
+        # Check environment variable first
+        env_key = f"{section.upper()}_{key.upper()}"
+        env_value = os.getenv(env_key)
+        if env_value is not None:
+            return env_value
+        
+        # Fall back to direct environment variable
+        direct_env_value = os.getenv(key.upper())
+        if direct_env_value is not None:
+            return direct_env_value
+        
+        return default
+    
+    def getboolean(self, section: str, key: str, default: bool = False) -> bool:
+        """Get boolean configuration value."""
+        value = self.get(section, key, str(default))
+        if isinstance(value, bool):
+            return value
+        return value.lower() in ('true', '1', 'yes', 'on')
+    
+    def getint(self, section: str, key: str, default: int = 0) -> int:
+        """Get integer configuration value."""
+        value = self.get(section, key, str(default))
+        try:
+            return int(value)
+        except (ValueError, TypeError):
+            return default
+    
+    def get_all_settings(self) -> Dict[str, Dict[str, Any]]:
+        """Get all settings as dictionary."""
+        settings = {}
+        
+        # Telegram секция
+        settings['Telegram'] = {
+            'bot_token': self.get('Telegram', 'bot_token', ''),
+            'listen_bot_token': self.get('Telegram', 'listen_bot_token', ''),
+            'test_bot_token': self.get('Telegram', 'test_bot_token', ''),
+            'preview_link': self.getboolean('Telegram', 'preview_link', False),
+            'main_public': self.get('Telegram', 'main_public', ''),
+            'group_for_posts': self.getint('Telegram', 'group_for_posts', 0),
+            'group_for_message': self.getint('Telegram', 'group_for_message', 0),
+            'group_for_logs': self.getint('Telegram', 'group_for_logs', 0),
+            'important_logs': self.getint('Telegram', 'important_logs', 0),
+            'archive': self.getint('Telegram', 'archive', 0),
+            'test_group': self.getint('Telegram', 'test_group', 0)
+        }
+        
+        # Settings секция
+        settings['Settings'] = {
+            'logs': self.getboolean('Settings', 'logs', False),
+            'test': self.getboolean('Settings', 'test', False)
+        }
+        
+        return settings
+
+
+# Global config instance
+_config_instance: Optional[ConfigManager] = None
+
+
+def get_config() -> ConfigManager:
+    """Get global configuration instance."""
+    global _config_instance
+    if _config_instance is None:
+        _config_instance = ConfigManager()
+    return _config_instance

helper_bot/utils/messages.py

@@ -8,43 +8,45 @@ from .metrics import (
 )
 
 
+constants = {
+    'HELLO_MESSAGE': "Привет, username!👋🏼&Меня зовут Виби, я бот канала 'Влюбленный Бийск'❤🤖"
+                    "&Я был создан для того, чтобы помочь тебе выложить пост в наш канал и если это необходимо, связаться с админами ✍✉"
+                    "&Так же я могу выдать тебе набор стикеров, где я буду главным героем🦸‍♂"
+                    "&Наш бот голосового общения переехал сюда: https://t.me/podslushano_biysk_bot 🎤&Там можно послушать о чем говорит наш город🎧"
+                    "&Предлагай свой пост мне и я обязательно его опубликую😉"
+                    "&Для продолжения взаимодействия воспользуйся меню внизу твоего дисплея⬇"
+                    "&&Если что-то пошло не так: введи в чат команду /start, это перезапустит сценарий сначала."
+                    "&Не жми кнопку несколько раз если я не ответил с первого раза. Возможно ведутся тех.работы и я отвечу позже"
+                    "&&Основная группа в ВК: https://vk.com/love_bsk"
+                    "&Основной канал в ТГ: https://t.me/love_bsk",
+    'SUGGEST_NEWS': "username, окей, жду от тебя текст поста🙌🏼"
+                    "&Обрати внимание, что я умный и смогу из твоего текста понять команды указанные ниже😉"
+                    "&Если хочешь чтобы пост был опубликован анонимно, напиши в любом месте своего поста слово 'анон'."
+                    "&Если хочешь опубликовать пост не анонимно, то напиши 'не анон', 'неанон' или не пиши ничего."
+                    "&&❗️❗️Я обучен только на команды, указанные мной выше👆"
+                    "&❗️❗️Проверь, чтобы указание авторства было выполнено так как я попросил, иначе пост будет выложен не корректно"
+                    "&Пост будет опубликован только в группе ТГ📩",
+    "CONNECT_WITH_ADMIN": "username, напиши свое обращение или предложение✍️"
+                          "&Мы рассмотрим и ответим тебе в ближайшее время☺️❤️",
+    "DEL_MESSAGE": "username, напиши свое обращение или предложение✍"
+                   "&Мы рассмотрим и ответим тебе в ближайшее время☺❤",
+    "BYE_MESSAGE": "Если позднее захочешь предложить еще один пост или обратиться к админам с вопросом, то просто пришли в чат команду 👉 /restart"
+                   "&&И тебе пока!👋🏼❤️",
+    "USER_ERROR": "Увы, я не понимаю тебя😐💔 Выбери один из пунктов в нижнем меню, а затем пиши.",
+    "QUESTION": "Сообщение успешно отправлено❤️ Ответим, как только сможем😉",
+    "SUCCESS_SEND_MESSAGE": "Пост успешно отправлен❤️ Ожидай одобрения😊",
+    "MESSAGE_FOR_STANDUP": "Отлично, ты вошел в режим стендапа 📣"
+                           "&Это свободное пространство, в котором может высказаться каждый житель нашего города, и он будет услышан🙌🏼"
+                           "&Для того чтобы высказаться, нажми кнопку: 'Высказаться' и запиши голосовое сообщение, оно выпадет анонимно кому-то другому🗣"
+                           "&Для того чтобы послушать о чем говорит наш город, нажми кнопку: 'Послушать'👂"
+                           "&Ты можешь анонимно пообщаться, поделиться чем-то важным, обратиться напрямую к жителям🤝 Также можешь выступить перед аудиторией (спеть песню, рассказать стихотворение, шутку)🎤"
+                           "&❗️Но пожалуйста не оскорбляй никого, и будь вежлив."
+}
+
+
 @track_time("get_message", "message_service")
 @track_errors("message_service", "get_message")
 def get_message(username: str, type_message: str):
-    constants = {
-        'HELLO_MESSAGE': "Привет, username!👋🏼&Меня зовут Виби, я бот канала 'Влюбленный Бийск'❤🤖"
-                        "&Я был создан для того, чтобы помочь тебе выложить пост в наш канал и если это необходимо, связаться с админами ✍✉"
-                        "&Так же я могу выдать тебе набор стикеров, где я буду главным героем🦸‍♂"
-                        "&Наш бот голосового общения переехал сюда: https://t.me/podslushano_biysk_bot 🎤&Там можно послушать о чем говорит наш город🎧"
-                        "&Предлагай свой пост мне и я обязательно его опубликую😉"
-                        "&Для продолжения взаимодействия воспользуйся меню внизу твоего дисплея⬇"
-                        "&&Если что-то пошло не так: введи в чат команду /start, это перезапустит сценарий сначала."
-                        "&Не жми кнопку несколько раз если я не ответил с первого раза. Возможно ведутся тех.работы и я отвечу позже"
-                        "&&Основная группа в ВК: https://vk.com/love_bsk"
-                        "&Основной канал в ТГ: https://t.me/love_bsk",
-        'SUGGEST_NEWS': "username, окей, жду от тебя текст поста🙌🏼"
-                        "&Обрати внимание, что я умный и смогу из твоего текста понять команды указанные ниже😉"
-                        "&Если хочешь чтобы пост был опубликован анонимно, напиши в любом месте своего поста слово 'анон'."
-                        "&Если хочешь опубликовать пост не анонимно, то напиши 'не анон', 'неанон' или не пиши ничего."
-                        "&&❗️❗️Я обучен только на команды, указанные мной выше👆"
-                        "&❗️❗️Проверь, чтобы указание авторства было выполнено так как я попросил, иначе пост будет выложен не корректно"
-                        "&Пост будет опубликован только в группе ТГ📩",
-        "CONNECT_WITH_ADMIN": "username, напиши свое обращение или предложение✍️"
-                              "&Мы рассмотрим и ответим тебе в ближайшее время☺️❤️",
-        "DEL_MESSAGE": "username, напиши свое обращение или предложение✍"
-                       "&Мы рассмотрим и ответим тебе в ближайшее время☺❤",
-        "BYE_MESSAGE": "Если позднее захочешь предложить еще один пост или обратиться к админам с вопросом, то просто пришли в чат команду 👉 /restart"
-                       "&&И тебе пока!👋🏼❤️",
-        "USER_ERROR": "Увы, я не понимаю тебя😐💔 Выбери один из пунктов в нижнем меню, а затем пиши.",
-        "QUESTION": "Сообщение успешно отправлено❤️ Ответим, как только сможем😉",
-        "SUCCESS_SEND_MESSAGE": "Пост успешно отправлен❤️ Ожидай одобрения😊",
-        "MESSAGE_FOR_STANDUP": "Отлично, ты вошел в режим стендапа 📣"
-                               "&Это свободное пространство, в котором может высказаться каждый житель нашего города, и он будет услышан🙌🏼"
-                               "&Для того чтобы высказаться, нажми кнопку: 'Высказаться' и запиши голосовое сообщение, оно выпадет анонимно кому-то другому🗣"
-                               "&Для того чтобы послушать о чем говорит наш город, нажми кнопку: 'Послушать'👂"
-                               "&Ты можешь анонимно пообщаться, поделиться чем-то важным, обратиться напрямую к жителям🤝 Также можешь выступить перед аудиторией (спеть песню, рассказать стихотворение, шутку)🎤"
-                               "&❗️Но пожалуйста не оскорбляй никого, и будь вежлив."
-    }
     if username is None:
         # Поведение ожидаемое тестами: TypeError при username=None
         raise TypeError("username is None")

helper_bot/utils/metrics.py

@@ -22,7 +22,7 @@ class BotMetrics:
         self.bot_commands_total = Counter(
             'bot_commands_total',
             'Total number of bot commands processed',
-            ['command_type', 'handler_type', 'user_type'],
+            ['command', 'status', 'handler_type', 'user_type'],
             registry=self.registry
         )
         
@@ -62,6 +62,14 @@ class BotMetrics:
             registry=self.registry
         )
         
+        # Database queries counter
+        self.db_queries_total = Counter(
+            'db_queries_total',
+            'Total number of database queries executed',
+            ['query_type', 'table_name', 'operation'],
+            registry=self.registry
+        )
+        
         # Message processing metrics
         self.messages_processed_total = Counter(
             'messages_processed_total',
@@ -88,10 +96,11 @@ class BotMetrics:
             registry=self.registry
         )
     
-    def record_command(self, command_type: str, handler_type: str = "unknown", user_type: str = "unknown"):
+    def record_command(self, command_type: str, handler_type: str = "unknown", user_type: str = "unknown", status: str = "success"):
         """Record a bot command execution."""
         self.bot_commands_total.labels(
-            command_type=command_type,
+            command=command_type,
+            status=status,
             handler_type=handler_type,
             user_type=user_type
         ).inc()
@@ -123,6 +132,11 @@ class BotMetrics:
             table_name=table_name,
             operation=operation
         ).observe(duration)
+        self.db_queries_total.labels(
+            query_type=query_type,
+            table_name=table_name,
+            operation=operation
+        ).inc()
     
     def record_message(self, message_type: str, chat_type: str = "unknown", handler_type: str = "unknown"):
         """Record a processed message."""

helper_bot/utils/metrics_exporter.py

@@ -6,10 +6,139 @@ Provides HTTP endpoint for metrics collection and background metrics collection.
 import asyncio
 import logging
 from aiohttp import web
-from typing import Optional, Dict, Any
+from typing import Optional, Dict, Any, Protocol
 from .metrics import metrics
 
 
+class DatabaseProvider(Protocol):
+    """Protocol for database operations."""
+    
+    async def fetch_one(self, query: str) -> Optional[Dict[str, Any]]:
+        """Execute query and return single result."""
+        ...
+
+
+class MetricsCollector(Protocol):
+    """Protocol for metrics collection operations."""
+    
+    async def collect_user_metrics(self, db: DatabaseProvider) -> None:
+        """Collect user-related metrics."""
+        ...
+
+
+class UserMetricsCollector:
+    """Concrete implementation of user metrics collection."""
+    
+    def __init__(self, logger: logging.Logger):
+        self.logger = logger
+    
+    async def collect_user_metrics(self, db: DatabaseProvider) -> None:
+        """Collect user-related metrics from database."""
+        try:
+            # Проверяем, есть ли метод fetch_one (асинхронная БД)
+            if hasattr(db, 'fetch_one'):
+                active_users_query = """
+                    SELECT COUNT(DISTINCT user_id) as active_users
+                    FROM our_users 
+                    WHERE date_changed > datetime('now', '-1 day')
+                """
+                result = await db.fetch_one(active_users_query)
+                if result:
+                    metrics.set_active_users(result['active_users'], 'daily')
+                    self.logger.debug(f"Updated active users: {result['active_users']}")
+                else:
+                    metrics.set_active_users(0, 'daily')
+                    self.logger.debug("Updated active users: 0")
+            # Проверяем синхронную БД BotDB
+            elif hasattr(db, 'connect') and hasattr(db, 'cursor'):
+                # Используем синхронный запрос для BotDB в отдельном потоке
+                import asyncio
+                from concurrent.futures import ThreadPoolExecutor
+                
+                active_users_query = """
+                    SELECT COUNT(DISTINCT user_id) as active_users
+                    FROM our_users 
+                    WHERE date_changed > datetime('now', '-1 day')
+                """
+                
+                def sync_db_query():
+                    try:
+                        db.connect()
+                        db.cursor.execute(active_users_query)
+                        result = db.cursor.fetchone()
+                        return result[0] if result else 0
+                    finally:
+                        db.close()
+                
+                # Выполняем синхронный запрос в отдельном потоке
+                loop = asyncio.get_event_loop()
+                with ThreadPoolExecutor() as executor:
+                    result = await loop.run_in_executor(executor, sync_db_query)
+                
+                metrics.set_active_users(result, 'daily')
+                self.logger.debug(f"Updated active users: {result}")
+            else:
+                metrics.set_active_users(0, 'daily')
+                self.logger.warning("Database doesn't support fetch_one or connect methods")
+                
+        except Exception as e:
+            self.logger.error(f"Error collecting user metrics: {e}")
+            metrics.set_active_users(0, 'daily')
+
+
+class DependencyProvider(Protocol):
+    """Protocol for dependency injection."""
+    
+    def get_db(self) -> DatabaseProvider:
+        """Get database instance."""
+        ...
+
+
+class BackgroundMetricsCollector:
+    """Background service for collecting periodic metrics using dependency injection."""
+    
+    def __init__(
+        self, 
+        dependency_provider: DependencyProvider,
+        metrics_collector: MetricsCollector,
+        interval: int = 60
+    ):
+        self.dependency_provider = dependency_provider
+        self.metrics_collector = metrics_collector
+        self.interval = interval
+        self.running = False
+        self.logger = logging.getLogger(__name__)
+    
+    async def start(self):
+        """Start background metrics collection."""
+        self.running = True
+        self.logger.info("Background metrics collector started")
+        
+        while self.running:
+            try:
+                await self._collect_metrics()
+                await asyncio.sleep(self.interval)
+            except Exception as e:
+                self.logger.error(f"Error in background metrics collection: {e}")
+                await asyncio.sleep(self.interval)
+    
+    async def stop(self):
+        """Stop background metrics collection."""
+        self.running = False
+        self.logger.info("Background metrics collector stopped")
+    
+    async def _collect_metrics(self):
+        """Collect periodic metrics using dependency injection."""
+        try:
+            db = self.dependency_provider.get_db()
+            if db:
+                await self.metrics_collector.collect_user_metrics(db)
+            else:
+                self.logger.warning("Database not available for metrics collection")
+                
+        except Exception as e:
+            self.logger.error(f"Error collecting metrics: {e}")
+
 
 class MetricsExporter:
     """HTTP server for exposing Prometheus metrics."""
@@ -52,9 +181,6 @@ class MetricsExporter:
     async def metrics_handler(self, request: web.Request) -> web.Response:
         """Handle /metrics endpoint for Prometheus."""
         try:
-            # Log request for debugging
-            self.logger.info(f"Metrics request from {request.remote}: {request.headers.get('User-Agent', 'Unknown')}")
-            
             metrics_data = metrics.get_metrics()
             self.logger.debug(f"Generated metrics: {len(metrics_data)} bytes")
             
@@ -88,90 +214,21 @@ class MetricsExporter:
         })
 
 
-class BackgroundMetricsCollector:
-    """Background service for collecting periodic metrics."""
-    
-    def __init__(self, db: Optional[Any] = None, interval: int = 60):
-        self.db = db
-        self.interval = interval
-        self.running = False
-        self.logger = logging.getLogger(__name__)
-    
-    async def start(self):
-        """Start background metrics collection."""
-        self.running = True
-        self.logger.info("Background metrics collector started")
-        
-        while self.running:
-            try:
-                await self._collect_metrics()
-                await asyncio.sleep(self.interval)
-            except Exception as e:
-                self.logger.error(f"Error in background metrics collection: {e}")
-                await asyncio.sleep(self.interval)
-    
-    async def stop(self):
-        """Stop background metrics collection."""
-        self.running = False
-        self.logger.info("Background metrics collector stopped")
-    
-    async def _collect_metrics(self):
-        """Collect periodic metrics."""
-        try:
-            # Collect active users count if database is available
-            if self.db:
-                await self._collect_user_metrics()
-            
-            # Collect system metrics
-            await self._collect_system_metrics()
-            
-        except Exception as e:
-            self.logger.error(f"Error collecting metrics: {e}")
-    
-    async def _collect_user_metrics(self):
-        """Collect user-related metrics from database."""
-        try:
-            if hasattr(self.db, 'fetch_one'):
-                # Try to get active users from database if it has async methods
-                try:
-                    active_users_query = """
-                        SELECT COUNT(DISTINCT user_id) as active_users
-                        FROM our_users 
-                        WHERE date_added > datetime('now', '-1 day')
-                    """
-                    result = await self.db.fetch_one(active_users_query)
-                    if result:
-                        metrics.set_active_users(result['active_users'], 'daily')
-                    else:
-                        metrics.set_active_users(0, 'daily')
-                except Exception as db_error:
-                    self.logger.warning(f"Database query failed, using placeholder: {db_error}")
-                    metrics.set_active_users(0, 'daily')
-            else:
-                # For now, set a placeholder value
-                metrics.set_active_users(0, 'daily')
-            
-        except Exception as e:
-            self.logger.error(f"Error collecting user metrics: {e}")
-            metrics.set_active_users(0, 'daily')
-    
-    async def _collect_system_metrics(self):
-        """Collect system-level metrics."""
-        try:
-            # Example: collect memory usage, CPU usage, etc.
-            # This can be extended based on your needs
-            pass
-            
-        except Exception as e:
-            self.logger.error(f"Error collecting system metrics: {e}")
-
-
 class MetricsManager:
     """Main class for managing metrics collection and export."""
     
-    def __init__(self, host: str = "0.0.0.0", port: int = 8000, db: Optional[Any] = None):
+    def __init__(self, host: str = "0.0.0.0", port: int = 8000):
         self.exporter = MetricsExporter(host, port)
-        self.collector = BackgroundMetricsCollector(db)
+        
+        # Dependency injection setup
+        from helper_bot.utils.base_dependency_factory import get_global_instance
+        dependency_provider = get_global_instance()
+        metrics_collector = UserMetricsCollector(logging.getLogger(__name__))
+        
+        self.collector = BackgroundMetricsCollector(
+            dependency_provider=dependency_provider,
+            metrics_collector=metrics_collector
+        )
         self.logger = logging.getLogger(__name__)
     
     async def start(self):