Refactor project structure and enhance Docker support

- Removed unnecessary `__init__.py` and `Dockerfile` to streamline project organization.
- Updated `.dockerignore` and `.gitignore` to improve exclusion patterns for build artifacts and environment files.
- Enhanced `Makefile` with new commands for managing Docker containers and added help documentation.
- Introduced `pyproject.toml` for better project metadata management and dependency tracking.
- Updated `requirements.txt` to reflect changes in dependencies for metrics and monitoring.
- Refactored various handler files to improve code organization and maintainability.

helper_bot/utils/helper_func.py

@@ -3,6 +3,7 @@ import os
 import random
 from datetime import datetime, timedelta
 from time import sleep
+from typing import List, Dict, Any, Optional
 
 try:
     import emoji as _emoji_lib
@@ -14,6 +15,14 @@ from aiogram.types import InputMediaPhoto, FSInputFile, InputMediaVideo, InputMe
 from helper_bot.utils.base_dependency_factory import BaseDependencyFactory, get_global_instance
 from logs.custom_logger import logger
 
+# Local imports - metrics
+from .metrics import (
+    metrics, 
+    track_time, 
+    track_errors, 
+    db_query_time
+)
+
 bdf = get_global_instance()
 BotDB = bdf.get_db()
 GROUP_FOR_LOGS = bdf.settings['Telegram']['group_for_logs']
@@ -43,6 +52,8 @@ def safe_html_escape(text: str) -> str:
     return html.escape(str(text))
 
 
+@track_time("get_first_name", "helper_func")
+@track_errors("helper_func", "get_first_name")
 def get_first_name(message: types.Message) -> str:
     """
     Безопасно получает и экранирует имя пользователя для использования в HTML разметке.
@@ -234,7 +245,7 @@ async def add_in_db_media(sent_message, bot_db):
 
 
 async def send_media_group_message_to_private_chat(chat_id: int, message: types.Message,
-                                                   media_group: list[InputMediaPhoto], bot_db):
+                                                   media_group: List, bot_db):
     sent_message = await message.bot.send_media_group(
         chat_id=chat_id,
         media=media_group,
@@ -245,7 +256,7 @@ async def send_media_group_message_to_private_chat(chat_id: int, message: types.
     return message_id
 
 
-async def send_media_group_to_channel(bot, chat_id: int, post_content: list[tuple[str]], post_text: str):
+async def send_media_group_to_channel(bot, chat_id: int, post_content: List, post_text: str):
     """
     Отправляет медиа-группу с подписью к последнему файлу.
 
@@ -458,6 +469,9 @@ def delete_user_blacklist(user_id: int, bot_db):
     return bot_db.delete_user_blacklist(user_id=user_id)
 
 
+@track_time("check_username_and_full_name", "helper_func")
+@track_errors("helper_func", "check_username_and_full_name")
+@db_query_time("get_username_and_full_name", "users", "select")
 def check_username_and_full_name(user_id: int, username: str, full_name: str, bot_db):
     username_db, full_name_db = bot_db.get_username_and_full_name(user_id=user_id)
     return username != username_db or full_name != full_name_db
@@ -479,6 +493,8 @@ def unban_notifier(self):
     self.bot.send_message(self.GROUP_FOR_MESSAGE, message)
 
 
+@track_time("update_user_info", "helper_func")
+@track_errors("helper_func", "update_user_info")
 async def update_user_info(source: str, message: types.Message):
     # Собираем данные
     full_name = message.from_user.full_name
@@ -495,10 +511,12 @@ async def update_user_info(source: str, message: types.Message):
     if not BotDB.user_exists(user_id):
         BotDB.add_new_user_in_db(user_id, first_name, full_name, username, is_bot, language_code, user_emoji, date,
                                  date)
+        metrics.record_db_query("add_new_user_in_db", 0.0, "users", "insert")
     else:
         is_need_update = check_username_and_full_name(user_id, username, full_name, BotDB)
         if is_need_update:
             BotDB.update_username_and_full_name(user_id, username, full_name)
+            metrics.record_db_query("update_username_and_full_name", 0.0, "users", "update")
             if source != 'voice':
                 await message.answer(
                     f"Давно не виделись! Вижу что ты изменился;) Теперь буду звать тебя: {full_name}")
@@ -506,17 +524,25 @@ async def update_user_info(source: str, message: types.Message):
                                            text=f'Для пользователя: {user_id} обновлены данные в БД.\nНовое имя: {full_name}\nНовый ник:{username}. Новый эмодзи:{user_emoji}')
         sleep(1)
     BotDB.update_date_for_user(date, user_id)
+    metrics.record_db_query("update_date_for_user", 0.0, "users", "update")
 
 
+@track_time("check_user_emoji", "helper_func")
+@track_errors("helper_func", "check_user_emoji")
+@db_query_time("check_emoji_for_user", "users", "select")
 def check_user_emoji(message: types.Message):
     user_id = message.from_user.id
     user_emoji = BotDB.check_emoji_for_user(user_id=user_id)
     if user_emoji is None or user_emoji in ("Смайл еще не определен", "Эмоджи не определен", ""):
         user_emoji = get_random_emoji()
         BotDB.update_emoji_for_user(user_id=user_id, emoji=user_emoji)
+        metrics.record_db_query("update_emoji_for_user", 0.0, "users", "update")
     return user_emoji
 
 
+@track_time("get_random_emoji", "helper_func")
+@track_errors("helper_func", "get_random_emoji")
+@db_query_time("check_emoji", "users", "select")
 def get_random_emoji():
     attempts = 0
     while attempts < 100:

helper_bot/utils/messages.py

@@ -1,6 +1,15 @@
 import html
 
+# Local imports - metrics
+from .metrics import (
+    metrics, 
+    track_time, 
+    track_errors
+)
 
+
+@track_time("get_message", "message_service")
+@track_errors("message_service", "get_message")
 def get_message(username: str, type_message: str):
     constants = {
         'HELLO_MESSAGE': "Привет, username!👋🏼&Меня зовут Виби, я бот канала 'Влюбленный Бийск'❤🤖"

helper_bot/utils/metrics.py

@@ -0,0 +1,300 @@
+"""
+Metrics module for Telegram bot monitoring with Prometheus.
+Provides predefined metrics for bot commands, errors, performance, and user activity.
+"""
+
+from typing import Dict, Any, Optional
+from prometheus_client import Counter, Histogram, Gauge, generate_latest, CONTENT_TYPE_LATEST
+from prometheus_client.core import CollectorRegistry
+import time
+from functools import wraps
+import asyncio
+from contextlib import asynccontextmanager
+
+
+class BotMetrics:
+    """Central class for managing all bot metrics."""
+    
+    def __init__(self):
+        self.registry = CollectorRegistry()
+        
+        # Bot commands counter
+        self.bot_commands_total = Counter(
+            'bot_commands_total',
+            'Total number of bot commands processed',
+            ['command_type', 'handler_type', 'user_type'],
+            registry=self.registry
+        )
+        
+        # Method execution time histogram
+        self.method_duration_seconds = Histogram(
+            'method_duration_seconds',
+            'Time spent executing methods',
+            ['method_name', 'handler_type', 'status'],
+            buckets=[0.1, 0.25, 0.5, 1.0, 2.5, 5.0, 10.0],
+            registry=self.registry
+        )
+        
+        # Errors counter
+        self.errors_total = Counter(
+            'errors_total',
+            'Total number of errors',
+            ['error_type', 'handler_type', 'method_name'],
+            registry=self.registry
+        )
+        
+        # Active users gauge
+        self.active_users = Gauge(
+            'active_users',
+            'Number of currently active users',
+            ['user_type'],
+            registry=self.registry
+        )
+        
+        # Database query metrics
+        self.db_query_duration_seconds = Histogram(
+            'db_query_duration_seconds',
+            'Time spent executing database queries',
+            ['query_type', 'table_name', 'operation'],
+            buckets=[0.01, 0.05, 0.1, 0.25, 0.5, 1.0, 2.5],
+            registry=self.registry
+        )
+        
+        # Message processing metrics
+        self.messages_processed_total = Counter(
+            'messages_processed_total',
+            'Total number of messages processed',
+            ['message_type', 'chat_type', 'handler_type'],
+            registry=self.registry
+        )
+        
+        # Middleware execution metrics
+        self.middleware_duration_seconds = Histogram(
+            'middleware_duration_seconds',
+            'Time spent in middleware execution',
+            ['middleware_name', 'status'],
+            buckets=[0.01, 0.05, 0.1, 0.25, 0.5],
+            registry=self.registry
+        )
+    
+    def record_command(self, command_type: str, handler_type: str = "unknown", user_type: str = "unknown"):
+        """Record a bot command execution."""
+        self.bot_commands_total.labels(
+            command_type=command_type,
+            handler_type=handler_type,
+            user_type=user_type
+        ).inc()
+    
+    def record_error(self, error_type: str, handler_type: str = "unknown", method_name: str = "unknown"):
+        """Record an error occurrence."""
+        self.errors_total.labels(
+            error_type=error_type,
+            handler_type=handler_type,
+            method_name=method_name
+        ).inc()
+    
+    def record_method_duration(self, method_name: str, duration: float, handler_type: str = "unknown", status: str = "success"):
+        """Record method execution duration."""
+        self.method_duration_seconds.labels(
+            method_name=method_name,
+            handler_type=handler_type,
+            status=status
+        ).observe(duration)
+    
+    def set_active_users(self, count: int, user_type: str = "total"):
+        """Set the number of active users."""
+        self.active_users.labels(user_type=user_type).set(count)
+    
+    def record_db_query(self, query_type: str, duration: float, table_name: str = "unknown", operation: str = "unknown"):
+        """Record database query duration."""
+        self.db_query_duration_seconds.labels(
+            query_type=query_type,
+            table_name=table_name,
+            operation=operation
+        ).observe(duration)
+    
+    def record_message(self, message_type: str, chat_type: str = "unknown", handler_type: str = "unknown"):
+        """Record a processed message."""
+        self.messages_processed_total.labels(
+            message_type=message_type,
+            chat_type=chat_type,
+            handler_type=handler_type
+        ).inc()
+    
+    def record_middleware(self, middleware_name: str, duration: float, status: str = "success"):
+        """Record middleware execution duration."""
+        self.middleware_duration_seconds.labels(
+            middleware_name=middleware_name,
+            status=status
+        ).observe(duration)
+    
+    def get_metrics(self) -> bytes:
+        """Generate metrics in Prometheus format."""
+        return generate_latest(self.registry)
+
+
+# Global metrics instance
+metrics = BotMetrics()
+
+
+# Decorators for easy metric collection
+def track_time(method_name: str = None, handler_type: str = "unknown"):
+    """Decorator to track execution time of functions."""
+    def decorator(func):
+        @wraps(func)
+        async def async_wrapper(*args, **kwargs):
+            start_time = time.time()
+            try:
+                result = await func(*args, **kwargs)
+                duration = time.time() - start_time
+                metrics.record_method_duration(
+                    method_name or func.__name__,
+                    duration,
+                    handler_type,
+                    "success"
+                )
+                return result
+            except Exception as e:
+                duration = time.time() - start_time
+                metrics.record_method_duration(
+                    method_name or func.__name__,
+                    duration,
+                    handler_type,
+                    "error"
+                )
+                metrics.record_error(
+                    type(e).__name__,
+                    handler_type,
+                    method_name or func.__name__
+                )
+                raise
+        
+        @wraps(func)
+        def sync_wrapper(*args, **kwargs):
+            start_time = time.time()
+            try:
+                result = func(*args, **kwargs)
+                duration = time.time() - start_time
+                metrics.record_method_duration(
+                    method_name or func.__name__,
+                    duration,
+                    handler_type,
+                    "success"
+                )
+                return result
+            except Exception as e:
+                duration = time.time() - start_time
+                metrics.record_method_duration(
+                    method_name or func.__name__,
+                    duration,
+                    handler_type,
+                    "error"
+                )
+                metrics.record_error(
+                    type(e).__name__,
+                    handler_type,
+                    method_name or func.__name__
+                )
+                raise
+        
+        if asyncio.iscoroutinefunction(func):
+            return async_wrapper
+        return sync_wrapper
+    return decorator
+
+
+def track_errors(handler_type: str = "unknown", method_name: str = None):
+    """Decorator to track errors in functions."""
+    def decorator(func):
+        @wraps(func)
+        async def async_wrapper(*args, **kwargs):
+            try:
+                return await func(*args, **kwargs)
+            except Exception as e:
+                metrics.record_error(
+                    type(e).__name__,
+                    handler_type,
+                    method_name or func.__name__
+                )
+                raise
+        
+        @wraps(func)
+        def sync_wrapper(*args, **kwargs):
+            try:
+                return func(*args, **kwargs)
+            except Exception as e:
+                metrics.record_error(
+                    type(e).__name__,
+                    handler_type,
+                    method_name or func.__name__
+                )
+                raise
+        
+        if asyncio.iscoroutinefunction(func):
+            return async_wrapper
+        return sync_wrapper
+    return decorator
+
+
+def db_query_time(query_type: str = "unknown", table_name: str = "unknown", operation: str = "unknown"):
+    """Decorator to track database query execution time."""
+    def decorator(func):
+        @wraps(func)
+        async def async_wrapper(*args, **kwargs):
+            start_time = time.time()
+            try:
+                result = await func(*args, **kwargs)
+                duration = time.time() - start_time
+                metrics.record_db_query(query_type, duration, table_name, operation)
+                return result
+            except Exception as e:
+                duration = time.time() - start_time
+                metrics.record_db_query(query_type, duration, table_name, operation)
+                metrics.record_error(
+                    type(e).__name__,
+                    "database",
+                    func.__name__
+                )
+                raise
+        
+        @wraps(func)
+        def sync_wrapper(*args, **kwargs):
+            start_time = time.time()
+            try:
+                result = func(*args, **kwargs)
+                duration = time.time() - start_time
+                metrics.record_db_query(query_type, duration, table_name, operation)
+                return result
+            except Exception as e:
+                duration = time.time() - start_time
+                metrics.record_db_query(query_type, duration, table_name, operation)
+                metrics.record_error(
+                    type(e).__name__,
+                    "database",
+                    func.__name__
+                )
+                raise
+        
+        if asyncio.iscoroutinefunction(func):
+            return async_wrapper
+        return sync_wrapper
+    return decorator
+
+
+@asynccontextmanager
+async def track_middleware(middleware_name: str):
+    """Context manager to track middleware execution time."""
+    start_time = time.time()
+    try:
+        yield
+        duration = time.time() - start_time
+        metrics.record_middleware(middleware_name, duration, "success")
+    except Exception as e:
+        duration = time.time() - start_time
+        metrics.record_middleware(middleware_name, duration, "error")
+        metrics.record_error(
+            type(e).__name__,
+            "middleware",
+            middleware_name
+        )
+        raise

helper_bot/utils/metrics_exporter.py

@@ -0,0 +1,201 @@
+"""
+Metrics exporter for Prometheus.
+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 .metrics import metrics
+
+
+
+class MetricsExporter:
+    """HTTP server for exposing Prometheus metrics."""
+    
+    def __init__(self, host: str = "0.0.0.0", port: int = 8000):
+        self.host = host
+        self.port = port
+        self.app = web.Application()
+        self.runner: Optional[web.AppRunner] = None
+        self.site: Optional[web.TCPSite] = None
+        self.logger = logging.getLogger(__name__)
+        
+        # Setup routes
+        self.app.router.add_get('/metrics', self.metrics_handler)
+        self.app.router.add_get('/health', self.health_handler)
+        self.app.router.add_get('/', self.root_handler)
+    
+    async def start(self):
+        """Start the metrics server."""
+        try:
+            self.runner = web.AppRunner(self.app)
+            await self.runner.setup()
+            
+            self.site = web.TCPSite(self.runner, self.host, self.port)
+            await self.site.start()
+            
+            self.logger.info(f"Metrics server started on {self.host}:{self.port}")
+        except Exception as e:
+            self.logger.error(f"Failed to start metrics server: {e}")
+            raise
+    
+    async def stop(self):
+        """Stop the metrics server."""
+        if self.site:
+            await self.site.stop()
+        if self.runner:
+            await self.runner.cleanup()
+        self.logger.info("Metrics server stopped")
+    
+    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")
+            
+            return web.Response(
+                body=metrics_data,
+                content_type='text/plain; version=0.0.4'
+            )
+        except Exception as e:
+            self.logger.error(f"Error generating metrics: {e}")
+            return web.Response(
+                text=f"Error generating metrics: {e}",
+                status=500
+            )
+    
+    async def health_handler(self, request: web.Request) -> web.Response:
+        """Handle /health endpoint for health checks."""
+        return web.json_response({
+            "status": "healthy",
+            "service": "telegram-bot-metrics"
+        })
+    
+    async def root_handler(self, request: web.Request) -> web.Response:
+        """Handle root endpoint with basic info."""
+        return web.json_response({
+            "service": "Telegram Bot Metrics Exporter",
+            "endpoints": {
+                "/metrics": "Prometheus metrics",
+                "/health": "Health check",
+                "/": "This info"
+            }
+        })
+
+
+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):
+        self.exporter = MetricsExporter(host, port)
+        self.collector = BackgroundMetricsCollector(db)
+        self.logger = logging.getLogger(__name__)
+    
+    async def start(self):
+        """Start metrics collection and export."""
+        try:
+            # Start metrics exporter
+            await self.exporter.start()
+            
+            # Start background collector
+            asyncio.create_task(self.collector.start())
+            
+            self.logger.info("Metrics manager started successfully")
+            
+        except Exception as e:
+            self.logger.error(f"Failed to start metrics manager: {e}")
+            raise
+    
+    async def stop(self):
+        """Stop metrics collection and export."""
+        try:
+            await self.collector.stop()
+            await self.exporter.stop()
+            self.logger.info("Metrics manager stopped successfully")
+            
+        except Exception as e:
+            self.logger.error(f"Error stopping metrics manager: {e}")
+            raise