refactor(logging): logging and rename token env

bot/handlers/bots.py

@@ -3,39 +3,67 @@ from aiogram.types import CallbackQuery
 
 from bot.api.asf import get_all_bots
 from bot.filters import AdminCallbackFilter
+from bot.logging_utils import describe_user, get_logger
 from bot.services.bots import is_idle_enabled, update_idle_game
 from bot.services.twofa import stop_twofa_task
 from bot.ui.formatters import format_bot_ui, get_farm_summary
 from bot.ui.keyboards import bot_details_keyboard, bots_keyboard, games_keyboard
 
 router = Router()
+logger = get_logger(__name__)
 
 
 @router.callback_query(lambda c: c.data == "bot_loading", AdminCallbackFilter())
 async def bot_loading_handler(callback: CallbackQuery) -> None:
+    logger.info(
+        "Пользователь %s нажал на еще не загруженного бота",
+        describe_user(callback.from_user),
+    )
     await callback.answer(
-        "Аккаунт ещё загружается. Попробуйте через несколько секунд.",
+        "Аккаунт еще загружается. Попробуйте через несколько секунд.",
         show_alert=True,
     )
 
 
 @router.callback_query(lambda c: c.data == "bots", AdminCallbackFilter())
 async def bots_handler(callback: CallbackQuery) -> None:
+    logger.info(
+        "Пользователь %s открыл список ботов",
+        describe_user(callback.from_user),
+    )
     await stop_twofa_task(callback.message.message_id)  # type: ignore[union-attr]
     await callback.answer()
     try:
         response = get_all_bots()
         if response.status_code != 200:
+            logger.warning(
+                "Не удалось загрузить список ботов для %s: HTTP %s",
+                describe_user(callback.from_user),
+                response.status_code,
+            )
             await callback.message.edit_text("Ошибка API")  # type: ignore[union-attr]
             return
         data = response.json()
         if not data.get("Success"):
+            logger.warning(
+                "ASF вернул неуспешный ответ при загрузке списка ботов для %s",
+                describe_user(callback.from_user),
+            )
             await callback.message.edit_text("ASF вернул ошибку")  # type: ignore[union-attr]
             return
         bots = data.get("Result", {})
+        logger.info(
+            "Список ботов для %s загружен: %s бот(ов)",
+            describe_user(callback.from_user),
+            len(bots),
+        )
         text = f"<b>🤖 Ботов всего:</b> {len(bots)}\n\n{get_farm_summary(bots)}"
         await callback.message.edit_text(text, reply_markup=bots_keyboard(bots))  # type: ignore[union-attr]
     except Exception as error:
+        logger.exception(
+            "Ошибка при открытии списка ботов для %s",
+            describe_user(callback.from_user),
+        )
         await callback.message.edit_text(f"Ошибка: {error}")  # type: ignore[union-attr]
 
 
@@ -46,18 +74,37 @@ async def bot_selected(callback: CallbackQuery) -> None:
     await stop_twofa_task(callback.message.message_id)  # type: ignore[union-attr]
     await callback.answer()
     if not callback.data:
+        logger.debug(
+            "Колбэк выбора бота пришел без data от %s",
+            describe_user(callback.from_user),
+        )
         return
     bot_name = callback.data.replace("bot_", "")
+    logger.info(
+        "Пользователь %s выбрал бота %s",
+        describe_user(callback.from_user),
+        bot_name,
+    )
     try:
         data = get_all_bots().json()
         bots = data.get("Result", {})
         bot = bots.get(bot_name)
         if not bot or not bot.get("BotName") or not bot.get("SteamID"):
+            logger.info(
+                "Бот %s еще не готов к отображению для %s",
+                bot_name,
+                describe_user(callback.from_user),
+            )
             await callback.answer(
-                "Аккаунт ещё загружается. Попробуйте через несколько секунд.",
+                "Аккаунт еще загружается. Попробуйте через несколько секунд.",
                 show_alert=True,
             )
             return
+        logger.info(
+            "Открыта карточка бота %s для %s",
+            bot_name,
+            describe_user(callback.from_user),
+        )
         await callback.message.edit_text(  # type: ignore[union-attr]
             format_bot_ui(bot),
             disable_web_page_preview=True,
@@ -66,6 +113,11 @@ async def bot_selected(callback: CallbackQuery) -> None:
             ),
         )
     except Exception as error:
+        logger.exception(
+            "Ошибка при открытии карточки бота %s для %s",
+            bot_name,
+            describe_user(callback.from_user),
+        )
         await callback.message.edit_text(f"Ошибка: {error}")  # type: ignore[union-attr]
 
 
@@ -75,9 +127,19 @@ async def bot_selected(callback: CallbackQuery) -> None:
 async def games(callback: CallbackQuery) -> None:
     await callback.answer()
     if not callback.data:
+        logger.debug(
+            "Колбэк выбора игры пришел без data от %s",
+            describe_user(callback.from_user),
+        )
         return
     bot_name = callback.data.replace("games_", "")
     idle_enabled = is_idle_enabled(bot_name, 730)
+    logger.info(
+        "Пользователь %s открыл меню накрутки часов для бота %s. CS2=%s",
+        describe_user(callback.from_user),
+        bot_name,
+        idle_enabled,
+    )
     await callback.message.edit_text(  # type: ignore[union-attr]
         "⌚ Выберите игру для накрутки часов",
         reply_markup=games_keyboard(bot_name, idle_enabled),
@@ -90,16 +152,42 @@ async def games(callback: CallbackQuery) -> None:
 async def farm_game(callback: CallbackQuery) -> None:
     await callback.answer()
     if not callback.data:
+        logger.debug(
+            "Колбэк изменения фарма пришел без data от %s",
+            describe_user(callback.from_user),
+        )
         return
     _, bot_name, app_id_value = callback.data.split("|")
+    logger.info(
+        "Пользователь %s меняет игру для накрутки на боте %s: app_id=%s",
+        describe_user(callback.from_user),
+        bot_name,
+        app_id_value,
+    )
     success, text, enabled = await update_idle_game(bot_name, int(app_id_value))
     if not success:
+        logger.warning(
+            "Не удалось изменить игру для накрутки на боте %s для %s: %s",
+            bot_name,
+            describe_user(callback.from_user),
+            text,
+        )
         await callback.answer(text, show_alert=True)
         return
+    logger.info(
+        "Игра для накрутки на боте %s обновлена для %s. CS2=%s",
+        bot_name,
+        describe_user(callback.from_user),
+        enabled,
+    )
     await callback.answer(text, show_alert=True)
     try:
         await callback.message.edit_reply_markup(  # type: ignore[union-attr]
             reply_markup=games_keyboard(bot_name, enabled)
         )
     except Exception:
-        pass
+        logger.debug(
+            "Не удалось обновить клавиатуру игр для бота %s",
+            bot_name,
+            exc_info=True,
+        )

bot/handlers/console.py

@@ -2,15 +2,19 @@ from aiogram import Router
 from aiogram.types import CallbackQuery
 
 from bot.filters import AdminCallbackFilter
+from bot.logging_utils import describe_user, get_logger
 from bot.state import console_users
 from bot.ui.formatters import get_asf_status_text
 from bot.ui.keyboards import console_keyboard, main_keyboard
 
 router = Router()
+logger = get_logger(__name__)
 
 
 @router.callback_query(lambda c: c.data == "console", AdminCallbackFilter())
 async def console_enter(callback: CallbackQuery) -> None:
+    user = describe_user(callback.from_user.id)
+    logger.info("Пользователь вошел в режим консоли ASF: %s", user)
     await callback.answer()
     console_users.add(callback.from_user.id)
     await callback.message.edit_text(  # type: ignore[union-attr]
@@ -21,6 +25,8 @@ async def console_enter(callback: CallbackQuery) -> None:
 
 @router.callback_query(lambda c: c.data == "console_exit", AdminCallbackFilter())
 async def console_exit(callback: CallbackQuery) -> None:
+    user = describe_user(callback.from_user.id)
+    logger.info("Пользователь вышел из режима консоли ASF: %s", user)
     await callback.answer()
     console_users.discard(callback.from_user.id)
     await callback.message.edit_text(get_asf_status_text(), reply_markup=main_keyboard())  # type: ignore[union-attr]

bot/handlers/inventory.py

@@ -2,21 +2,26 @@ from aiogram import Router
 from aiogram.types import CallbackQuery
 
 from bot.filters import AdminCallbackFilter
+from bot.logging_utils import describe_user, get_logger
 from bot.services.inventory import build_inventory_menu, render_inventory_page
 from bot.ui.keyboards import back_keyboard
 
 router = Router()
+logger = get_logger(__name__)
 
 
 @router.callback_query(
     lambda c: c.data and c.data.startswith("inventory_"), AdminCallbackFilter()
 )
 async def inventory_menu(callback: CallbackQuery) -> None:
-    await callback.answer()
+    user = describe_user(callback.from_user.id)
     bot_name = callback.data.replace("inventory_", "")  # type: ignore[union-attr]
+    logger.info("Открыто меню инвентаря: %s bot=%s", user, bot_name)
+    await callback.answer()
     await callback.message.edit_text("Проверка inventory...")  # type: ignore[union-attr]
     text, keyboard = await build_inventory_menu(bot_name)
-    if "пуст" in text:
+    if "пуст" in text.lower():
+        logger.info("Показано пустое меню инвентаря: %s bot=%s", user, bot_name)
         keyboard = back_keyboard(f"bot_{bot_name}")
     await callback.message.edit_text(text, reply_markup=keyboard)  # type: ignore[union-attr]
 
@@ -25,11 +30,14 @@ async def inventory_menu(callback: CallbackQuery) -> None:
     lambda c: c.data and c.data.startswith("inv_cs2_"), AdminCallbackFilter()
 )
 async def cs2_inventory(callback: CallbackQuery) -> None:
-    await callback.answer()
+    user = describe_user(callback.from_user.id)
     bot_name = callback.data.replace("inv_cs2_", "")  # type: ignore[union-attr]
+    logger.info("Открыт CS2-инвентарь: %s bot=%s", user, bot_name)
+    await callback.answer()
     await callback.message.edit_text("Загрузка inventory...")  # type: ignore[union-attr]
     text, keyboard = await render_inventory_page(bot_name, "cs2", 730, 2, 0)
     if text is None:
+        logger.warning("Не удалось загрузить CS2-инвентарь: %s bot=%s", user, bot_name)
         await callback.message.edit_text("Не удалось загрузить inventory")  # type: ignore[union-attr]
         return
     await callback.message.edit_text(text, reply_markup=keyboard)  # type: ignore[union-attr]
@@ -39,11 +47,14 @@ async def cs2_inventory(callback: CallbackQuery) -> None:
     lambda c: c.data and c.data.startswith("inv_steam_"), AdminCallbackFilter()
 )
 async def steam_inventory(callback: CallbackQuery) -> None:
-    await callback.answer()
+    user = describe_user(callback.from_user.id)
     bot_name = callback.data.replace("inv_steam_", "")  # type: ignore[union-attr]
+    logger.info("Открыт Steam-инвентарь: %s bot=%s", user, bot_name)
+    await callback.answer()
     await callback.message.edit_text("Загрузка inventory...")  # type: ignore[union-attr]
     text, keyboard = await render_inventory_page(bot_name, "steam", 753, 6, 0)
     if text is None:
+        logger.warning("Не удалось загрузить Steam-инвентарь: %s bot=%s", user, bot_name)
         await callback.message.edit_text("Не удалось загрузить inventory")  # type: ignore[union-attr]
         return
     await callback.message.edit_text(text, reply_markup=keyboard)  # type: ignore[union-attr]
@@ -53,13 +64,28 @@ async def steam_inventory(callback: CallbackQuery) -> None:
     lambda c: c.data and c.data.startswith("invpage|"), AdminCallbackFilter()
 )
 async def inventory_page(callback: CallbackQuery) -> None:
-    await callback.answer()
+    user = describe_user(callback.from_user.id)
     _, inv_type, bot_name, page_value = callback.data.split("|")  # type: ignore[union-attr]
+    logger.info(
+        "Открыта страница инвентаря: %s bot=%s type=%s page=%s",
+        user,
+        bot_name,
+        inv_type,
+        page_value,
+    )
+    await callback.answer()
     app_id, context_id = (730, 2) if inv_type == "cs2" else (753, 6)
     text, keyboard = await render_inventory_page(
         bot_name, inv_type, app_id, context_id, int(page_value)
     )
     if text is None:
+        logger.warning(
+            "Не удалось загрузить страницу инвентаря: %s bot=%s type=%s page=%s",
+            user,
+            bot_name,
+            inv_type,
+            page_value,
+        )
         await callback.message.edit_text("Не удалось загрузить inventory")  # type: ignore[union-attr]
         return
     await callback.message.edit_text(text, reply_markup=keyboard)  # type: ignore[union-attr]

bot/handlers/messages.py

@@ -5,6 +5,7 @@ from aiogram.types import Message
 
 from bot.api.asf import get_all_bots, send_command
 from bot.filters import AdminFilter
+from bot.logging_utils import describe_user, get_logger
 from bot.services.redeem import (
     extract_keys,
     redeem_all_bots_keys,
@@ -25,29 +26,60 @@ from bot.ui.keyboards import (
 )
 
 router = Router()
+logger = get_logger(__name__)
 
 
 async def handle_console_message(message: Message) -> bool:
     if message.from_user.id not in console_users:  # type: ignore[union-attr]
         return False
     command = message.text.strip()  # type: ignore[union-attr]
+    logger.info(
+        "Пользователь %s отправил консольную команду: %s",
+        describe_user(message.from_user),
+        command,
+    )
     try:
         await message.delete()
     except Exception:
-        pass
+        logger.debug(
+            "Не удалось удалить сообщение с консольной командой от %s",
+            describe_user(message.from_user),
+            exc_info=True,
+        )
     try:
         response = send_command(f"!{command}")
         if response.status_code != 200:
+            logger.warning(
+                "ASF вернул HTTP %s на консольную команду '%s' от %s",
+                response.status_code,
+                command,
+                describe_user(message.from_user),
+            )
             text = f"Ошибка HTTP {response.status_code}"
         else:
             data = response.json()
             if not data.get("Success"):
+                logger.warning(
+                    "ASF вернул неуспешный ответ на консольную команду '%s' от %s",
+                    command,
+                    describe_user(message.from_user),
+                )
                 text = "Ошибка ASF"
             else:
+                logger.info(
+                    "Консольная команда '%s' от %s выполнена успешно",
+                    command,
+                    describe_user(message.from_user),
+                )
                 result = html.escape(str(data.get("Result", "Нет ответа")))
                 text = f"<b>Команда:</b> <code>{command}</code>\n\n<b>Ответ:</b>\n<code>{result}</code>"
         await message.answer(text, reply_markup=delete_message_keyboard())
     except Exception as error:
+        logger.exception(
+            "Ошибка при выполнении консольной команды '%s' от %s",
+            command,
+            describe_user(message.from_user),
+        )
         await message.answer(f"Ошибка: {error}")
     return True
 
@@ -57,6 +89,11 @@ async def handle_single_bot_redeem(message: Message) -> bool:
         return False
     bot_name = bot_redeem_users.pop(message.from_user.id)  # type: ignore[union-attr]
     menu_message = bot_redeem_messages.pop(message.from_user.id, None)  # type: ignore[union-attr]
+    logger.info(
+        "Пользователь %s отправил ключи для бота %s",
+        describe_user(message.from_user),
+        bot_name,
+    )
     if menu_message:
         try:
             response = get_all_bots()
@@ -70,17 +107,38 @@ async def handle_single_bot_redeem(message: Message) -> bool:
                     ),
                 )
         except Exception:
-            pass
+            logger.debug(
+                "Не удалось восстановить меню бота %s после ввода ключей от %s",
+                bot_name,
+                describe_user(message.from_user),
+                exc_info=True,
+            )
     try:
         await message.bot.delete_message(
             chat_id=message.chat.id, message_id=message.message_id
         )
     except Exception:
-        pass
+        logger.debug(
+            "Не удалось удалить сообщение с ключами для бота %s от %s",
+            bot_name,
+            describe_user(message.from_user),
+            exc_info=True,
+        )
     keys = extract_keys(message.text or "")
     if not keys:
+        logger.info(
+            "В сообщении от %s для бота %s не найдено ключей",
+            describe_user(message.from_user),
+            bot_name,
+        )
         await message.answer("Ключи не найдены")
         return True
+    logger.info(
+        "Для бота %s получено %s ключ(ей) от %s",
+        bot_name,
+        len(keys),
+        describe_user(message.from_user),
+    )
     checking = await message.answer(
         f"Аккаунт: <code>{bot_name}</code>\nНайдено ключей: {len(keys)}\nНачинаю активацию..."
     )
@@ -93,35 +151,64 @@ async def handle_all_bots_redeem(message: Message) -> bool:
         return False
     redeem_users.discard(message.from_user.id)  # type: ignore[union-attr]
     menu_message = redeem_messages.pop(message.from_user.id, None)  # type: ignore[union-attr]
+    logger.info(
+        "Пользователь %s отправил ключи для активации на всех ботах",
+        describe_user(message.from_user),
+    )
     if menu_message:
         try:
             await menu_message.edit_text(
                 get_asf_status_text(), reply_markup=main_keyboard()
             )
         except Exception:
-            pass
+            logger.debug(
+                "Не удалось восстановить главное меню после массовой активации для %s",
+                describe_user(message.from_user),
+                exc_info=True,
+            )
     try:
         await message.bot.delete_message(
             chat_id=message.chat.id, message_id=message.message_id
         )
     except Exception:
-        pass
+        logger.debug(
+            "Не удалось удалить сообщение с массовой активацией от %s",
+            describe_user(message.from_user),
+            exc_info=True,
+        )
     keys = extract_keys(message.text or "")
     if not keys:
+        logger.info(
+            "В сообщении от %s для массовой активации не найдено ключей",
+            describe_user(message.from_user),
+        )
         await message.answer("Ключи не найдены")
         return True
+    logger.info(
+        "Для массовой активации получено %s ключ(ей) от %s",
+        len(keys),
+        describe_user(message.from_user),
+    )
     checking = await message.answer(
         f"Найдено ключей: {len(keys)}\nНачинаю активацию..."
     )
     try:
         await checking.edit_text(await redeem_all_bots_keys(keys))
     except Exception as error:
+        logger.exception(
+            "Ошибка при массовой активации ключей от %s",
+            describe_user(message.from_user),
+        )
         await checking.edit_text(f"Ошибка: {error}")
     return True
 
 
 @router.message(AdminFilter())
 async def text_router(message: Message) -> None:
+    logger.debug(
+        "Получено текстовое сообщение от %s для маршрутизации",
+        describe_user(message.from_user),
+    )
     if await handle_console_message(message):
         return
     if await handle_single_bot_redeem(message):

bot/handlers/navigation.py

@@ -5,6 +5,7 @@ from aiogram.types import CallbackQuery
 
 from bot.api.asf import get_plugins, restart_asf as restart_asf_request
 from bot.filters import AdminCallbackFilter
+from bot.logging_utils import describe_user, get_logger
 from bot.services.twofa import stop_twofa_task
 from bot.state import (
     bot_redeem_messages,
@@ -17,6 +18,7 @@ from bot.ui.formatters import get_asf_status_text
 from bot.ui.keyboards import back_keyboard, confirm_action_keyboard, main_keyboard
 
 router = Router()
+logger = get_logger(__name__)
 
 
 def clear_user_state(user_id: int) -> None:
@@ -25,39 +27,53 @@ def clear_user_state(user_id: int) -> None:
     console_users.discard(user_id)
     bot_redeem_users.pop(user_id, None)
     bot_redeem_messages.pop(user_id, None)
+    logger.info("Состояние пользователя очищено: user_id=%s", user_id)
 
 
 @router.callback_query(lambda c: c.data == "back", AdminCallbackFilter())
 async def back_button(callback: CallbackQuery) -> None:
+    user = describe_user(callback.from_user.id)
+    logger.info("Нажата кнопка возврата: %s", user)
     clear_user_state(callback.from_user.id)
     await stop_twofa_task(callback.message.message_id)  # type: ignore[union-attr]
     await callback.answer()
     try:
         await callback.message.edit_text(get_asf_status_text(), reply_markup=main_keyboard())  # type: ignore[union-attr]
+        logger.info("Пользователь возвращен в главное меню: %s", user)
     except Exception as error:
+        logger.exception("Не удалось вернуть пользователя в главное меню: %s", user)
         await callback.message.edit_text(f"Ошибка: {error}")  # type: ignore[union-attr]
 
 
 @router.callback_query(lambda c: c.data == "refresh", AdminCallbackFilter())
 async def refresh_handler(callback: CallbackQuery) -> None:
+    user = describe_user(callback.from_user.id)
+    logger.info("Запрошено обновление главного экрана: %s", user)
     await callback.answer()
     try:
         await callback.message.edit_text(get_asf_status_text(), reply_markup=main_keyboard())  # type: ignore[union-attr]
+        logger.info("Главный экран обновлен: %s", user)
     except Exception as error:
+        logger.exception("Не удалось обновить главный экран: %s", user)
         await callback.message.edit_text(f"Ошибка: {error}")  # type: ignore[union-attr]
 
 
 @router.callback_query(lambda c: c.data == "delete_msg", AdminCallbackFilter())
 async def delete_message(callback: CallbackQuery) -> None:
+    user = describe_user(callback.from_user.id)
+    logger.info("Запрошено удаление сообщения: %s", user)
     await callback.answer()
     try:
         await callback.message.delete()  # type: ignore[union-attr]
+        logger.info("Сообщение удалено: %s", user)
     except Exception:
-        pass
+        logger.exception("Не удалось удалить сообщение: %s", user)
 
 
 @router.callback_query(lambda c: c.data == "restart_asf_confirm", AdminCallbackFilter())
 async def restart_asf_confirm(callback: CallbackQuery) -> None:
+    user = describe_user(callback.from_user.id)
+    logger.info("Открыто подтверждение перезапуска ASF: %s", user)
     await callback.answer()
     await callback.message.edit_text(  # type: ignore[union-attr]
         "♻ Точно перезапустить ASF?\n\nВо время перезапуска IPC будет недоступен несколько секунд.",
@@ -67,11 +83,18 @@ async def restart_asf_confirm(callback: CallbackQuery) -> None:
 
 @router.callback_query(lambda c: c.data == "restart_asf", AdminCallbackFilter())
 async def restart_asf(callback: CallbackQuery) -> None:
+    user = describe_user(callback.from_user.id)
+    logger.info("Подтвержден перезапуск ASF: %s", user)
     await callback.answer()
     try:
         await callback.message.edit_text("♻ ASF перезапускается...")  # type: ignore[union-attr]
         response = restart_asf_request()
         if response.status_code != 200:
+            logger.warning(
+                "Перезапуск ASF завершился ошибкой HTTP: %s status=%s",
+                user,
+                response.status_code,
+            )
             await callback.message.edit_text(  # type: ignore[union-attr]
                 f"Ошибка HTTP {response.status_code}",
                 reply_markup=main_keyboard(),
@@ -82,7 +105,9 @@ async def restart_asf(callback: CallbackQuery) -> None:
             f"ASF успешно перезапущен\n\n{get_asf_status_text()}",
             reply_markup=main_keyboard(),
         )
+        logger.info("ASF успешно перезапущен: %s", user)
     except Exception as error:
+        logger.exception("Не удалось перезапустить ASF: %s", user)
         await callback.message.edit_text(  # type: ignore[union-attr]
             f"Ошибка: {error}",
             reply_markup=main_keyboard(),
@@ -91,21 +116,27 @@ async def restart_asf(callback: CallbackQuery) -> None:
 
 @router.callback_query(lambda c: c.data == "plugins", AdminCallbackFilter())
 async def plugins_handler(callback: CallbackQuery) -> None:
+    user = describe_user(callback.from_user.id)
+    logger.info("Открыт список плагинов ASF: %s", user)
     await stop_twofa_task(callback.message.message_id)  # type: ignore[union-attr]
     await callback.answer()
     try:
         response = get_plugins()
         if response.status_code != 200:
+            logger.warning("Не удалось получить список плагинов: %s status=%s", user, response.status_code)
             await callback.message.edit_text("Ошибка API")  # type: ignore[union-attr]
             return
         data = response.json()
         if not data.get("Success"):
+            logger.warning("ASF вернул ошибку при получении плагинов: %s", user)
             await callback.message.edit_text("ASF вернул ошибку")  # type: ignore[union-attr]
             return
         plugins = data.get("Result", [])
         if not plugins:
+            logger.info("Плагины ASF не установлены: %s", user)
             text = "Плагины не установлены"
         else:
+            logger.info("Получен список плагинов ASF: %s count=%s", user, len(plugins))
             text = "<b>📁 Плагины ASF:</b>\n\n"
             for plugin in plugins:
                 text += (
@@ -113,4 +144,5 @@ async def plugins_handler(callback: CallbackQuery) -> None:
                 )
         await callback.message.edit_text(text.strip(), reply_markup=back_keyboard())  # type: ignore[union-attr]
     except Exception as error:
+        logger.exception("Не удалось отобразить список плагинов: %s", user)
         await callback.message.edit_text(f"Ошибка: {error}")  # type: ignore[union-attr]

bot/handlers/redeem.py

@@ -2,6 +2,7 @@ from aiogram import Router
 from aiogram.types import CallbackQuery
 
 from bot.filters import AdminCallbackFilter
+from bot.logging_utils import describe_user, get_logger
 from bot.state import (
     bot_redeem_messages,
     bot_redeem_users,
@@ -11,10 +12,13 @@ from bot.state import (
 from bot.ui.keyboards import back_keyboard
 
 router = Router()
+logger = get_logger(__name__)
 
 
 @router.callback_query(lambda c: c.data == "redeem_keys", AdminCallbackFilter())
 async def redeem_keys_menu(callback: CallbackQuery) -> None:
+    user = describe_user(callback.from_user.id)
+    logger.info("Открыт режим активации ключей по всем ботам: %s", user)
     await callback.answer()
     redeem_users.add(callback.from_user.id)
     redeem_messages[callback.from_user.id] = callback.message
@@ -31,8 +35,10 @@ async def redeem_keys_menu(callback: CallbackQuery) -> None:
     lambda c: c.data and c.data.startswith("redeem_bot_"), AdminCallbackFilter()
 )
 async def redeem_bot_menu(callback: CallbackQuery) -> None:
-    await callback.answer()
+    user = describe_user(callback.from_user.id)
     bot_name = callback.data.replace("redeem_bot_", "")  # type: ignore[union-attr]
+    logger.info("Открыт режим активации ключей для одного бота: %s bot=%s", user, bot_name)
+    await callback.answer()
     bot_redeem_users[callback.from_user.id] = bot_name
     bot_redeem_messages[callback.from_user.id] = callback.message
     await callback.message.edit_text(  # type: ignore[union-attr]

bot/handlers/start.py

@@ -3,19 +3,26 @@ from aiogram.filters import Command
 from aiogram.types import Message
 
 from bot.filters import AdminFilter
+from bot.logging_utils import describe_user, get_logger
 from bot.ui.formatters import get_asf_status_text
 from bot.ui.keyboards import main_keyboard
 
 router = Router()
+logger = get_logger(__name__)
 
 
 @router.message(Command("start"), AdminFilter())
 async def start_handler(message: Message) -> None:
+    user = describe_user(message.from_user.id if message.from_user else None)
+    logger.info("Получена команда /start: %s", user)
     try:
         await message.delete()
+        logger.info("Сообщение /start удалено: %s", user)
     except Exception:
-        pass
+        logger.exception("Не удалось удалить сообщение /start: %s", user)
     try:
         await message.answer(get_asf_status_text(), reply_markup=main_keyboard())
+        logger.info("Главное меню отправлено: %s", user)
     except Exception as error:
+        logger.exception("Не удалось отправить главное меню: %s", user)
         await message.answer(f"Ошибка: {error}")

bot/handlers/twofa.py

@@ -5,11 +5,13 @@ from aiogram.types import CallbackQuery
 
 from bot.api.asf import accept_confirmations, get_confirmations
 from bot.filters import AdminCallbackFilter
+from bot.logging_utils import describe_user, get_logger
 from bot.services.twofa import auto_update_2fa, stop_twofa_task
 from bot.state import twofa_tasks
 from bot.ui.keyboards import back_keyboard, confirmations_keyboard
 
 router = Router()
+logger = get_logger(__name__)
 
 
 @router.callback_query(
@@ -21,9 +23,18 @@ router = Router()
 async def twofa_handler(callback: CallbackQuery) -> None:
     await callback.answer()
     if not callback.data:
+        logger.debug(
+            "Колбэк открытия 2FA пришел без data от %s",
+            describe_user(callback.from_user),
+        )
         return
     bot_name = callback.data.replace("2fa_", "")
     message_id = callback.message.message_id  # type: ignore[union-attr]
+    logger.info(
+        "Пользователь %s открыл 2FA для бота %s",
+        describe_user(callback.from_user),
+        bot_name,
+    )
     await stop_twofa_task(message_id)
     await callback.message.edit_text(  # type: ignore[union-attr]
         f"🔐 {bot_name}\n\nЗагрузка 2FA...",
@@ -31,6 +42,11 @@ async def twofa_handler(callback: CallbackQuery) -> None:
     )
     task = asyncio.create_task(auto_update_2fa(callback.message, bot_name))
     twofa_tasks[message_id] = task
+    logger.info(
+        "Запущено фоновое обновление 2FA для бота %s в сообщении %s",
+        bot_name,
+        message_id,
+    )
 
 
 @router.callback_query(
@@ -43,14 +59,29 @@ async def twofa_handler(callback: CallbackQuery) -> None:
 async def confirm_trades(callback: CallbackQuery) -> None:
     await callback.answer()
     bot_name = callback.data.replace("confirm_", "")  # type: ignore[union-attr]
+    logger.info(
+        "Пользователь %s подтвердил сделки для бота %s",
+        describe_user(callback.from_user),
+        bot_name,
+    )
     try:
         status = await accept_confirmations(bot_name)
         if status != 200:
+            logger.warning(
+                "Не удалось подтвердить сделки для бота %s: HTTP %s",
+                bot_name,
+                status,
+            )
             await callback.answer("Ошибка HTTP", show_alert=True)
             return
+        logger.info("Сделки для бота %s подтверждены", bot_name)
         await callback.answer("Подтверждено", show_alert=True)
         await twofa_handler(callback)
     except Exception as error:
+        logger.exception(
+            "Ошибка при подтверждении сделок для бота %s",
+            bot_name,
+        )
         await callback.message.edit_text(f"Ошибка: {error}")  # type: ignore[union-attr]
 
 
@@ -61,18 +92,37 @@ async def confirm_list(callback: CallbackQuery) -> None:
     await stop_twofa_task(callback.message.message_id)  # type: ignore[union-attr]
     await callback.answer()
     if not callback.data:
+        logger.debug(
+            "Колбэк списка подтверждений пришел без data от %s",
+            describe_user(callback.from_user),
+        )
         return
     bot_name = callback.data.replace("confirm_list_", "")
+    logger.info(
+        "Пользователь %s открыл список подтверждений для бота %s",
+        describe_user(callback.from_user),
+        bot_name,
+    )
     try:
         confirmations = await get_confirmations(bot_name)
         if not confirmations:
+            logger.info("Для бота %s подтверждений не найдено", bot_name)
             text = "Подтверждений нет"
         else:
+            logger.info(
+                "Для бота %s найдено %s подтверждени(й)",
+                bot_name,
+                len(confirmations),
+            )
             text = f"🔐 {bot_name}\n\nПодтверждения:\n\n"
             for conf in confirmations:
                 text += f"- {conf['type_name']}\nID: <code>{conf['id']}</code>\n\n"
         await callback.message.edit_text(text, reply_markup=confirmations_keyboard(bot_name))  # type: ignore[union-attr]
     except Exception as error:
+        logger.exception(
+            "Ошибка при загрузке списка подтверждений для бота %s",
+            bot_name,
+        )
         await callback.message.edit_text(f"Ошибка: {error}")  # type: ignore[union-attr]
 
 
@@ -83,21 +133,45 @@ async def confirm_all(callback: CallbackQuery) -> None:
     await stop_twofa_task(callback.message.message_id)  # type: ignore[union-attr]
     await callback.answer()
     if not callback.data:
+        logger.debug(
+            "Колбэк подтверждения всех сделок пришел без data от %s",
+            describe_user(callback.from_user),
+        )
         return
     bot_name = callback.data.replace("confirm_all_", "")
+    logger.info(
+        "Пользователь %s запустил подтверждение всех сделок для бота %s",
+        describe_user(callback.from_user),
+        bot_name,
+    )
     try:
         status = await accept_confirmations(bot_name)
         if status != 200:
+            logger.warning(
+                "Не удалось подтвердить все сделки для бота %s: HTTP %s",
+                bot_name,
+                status,
+            )
             await callback.answer("Ошибка HTTP", show_alert=True)
             return
         confirmations = await get_confirmations(bot_name)
         if not confirmations:
+            logger.info("После подтверждения у бота %s не осталось сделок", bot_name)
             text = f"🔐 {bot_name}\n\nПодтверждений больше нет"
         else:
+            logger.info(
+                "После подтверждения у бота %s осталось %s подтверждени(й)",
+                bot_name,
+                len(confirmations),
+            )
             text = f"🔐 {bot_name}\n\nПодтверждения:\n\n"
             for conf in confirmations:
                 text += f"- {conf['type_name']}\nID: <code>{conf['id']}</code>\n\n"
         await callback.message.edit_text(text, reply_markup=confirmations_keyboard(bot_name))  # type: ignore[union-attr]
         await callback.answer("Все подтверждено", show_alert=True)
     except Exception as error:
+        logger.exception(
+            "Ошибка при подтверждении всех сделок для бота %s",
+            bot_name,
+        )
         await callback.message.edit_text(f"Ошибка: {error}")  # type: ignore[union-attr]