Skip to content
The Chat Archive
claude-3-7-sonnet-20250219-thinking-32k· Anthropic LMArena Human Preference 140K

какие еще детские болячки проекта в коде могут быть, которые сильно замедляют его работу…

  1. User

    какие еще детские болячки проекта в коде могут быть, которые сильно замедляют его работу и которые нужно вычистить в проекте?

  2. Assistant

    Распространенные "детские болячки" в коде FastAPI+PostgreSQL проектов

    Помимо проблемы с соединениями, ваш проект может страдать от следующих частых проблем производительности:

    1. Неоптимальные SQL-запросы

    • N+1 запросы:

      # Антипаттерн:
      users = db.query(User).all()
      for user in users:
          # Отдельный запрос для каждого пользователя! (N+1)
          posts = db.query(Post).filter(Post.user_id == user.id).all()
      
      # Решение:
      users = db.query(User).options(joinedload(User.posts)).all()
      
    • Загрузка лишних данных:

      # Плохо - загружает все столбцы
      users = db.query(User).all()
      
      # Хорошо - загружает только нужные
      users = db.query(User.id, User.name).all()
      
    • Отсутствие индексов:

      -- Создайте индексы для частых фильтров и JOIN
      CREATE INDEX idx_posts_user_id ON posts(user_id);
      CREATE INDEX idx_users_email ON users(email);
      

    2. Блокирующие операции в асинхронном коде

    • Синхронные библиотеки:

      # Плохо - блокирует весь поток
      @app.get("/data")
      async def get_data():
          time.sleep(1)  # Блокирует весь асинхронный цикл!
          return {"data": "value"}
      
      # Хорошо
      @app.get("/data")
      async def get_data():
          await asyncio.sleep(1)
          return {"data": "value"}
      
    • CPU-интенсивные задачи:

      # Плохо - блокирует асинхронный цикл
      @app.get("/heavy")
      async def heavy_computation():
          result = compute_heavy_thing()  # Блокирует!
          return {"result": result}
      
      # Хорошо - использует ThreadPoolExecutor
      @app.get("/heavy")
      async def heavy_computation():
          loop = asyncio.get_running_loop()
          result = await loop.run_in_executor(None, compute_heavy_thing)
          return {"result": result}
      

    3. Неэффективная сериализация/десериализация

    • Избыточные Pydantic-модели:

      # Плохо - каждое поле проверяется и конвертируется
      @app.get("/users")
      async def get_users():
          users = await db.fetch_all("SELECT * FROM users")
          return [UserFullModel(**u) for u in users]  # Дорого!
      
      # Лучше - минимальная модель только с нужными полями
      @app.get("/users")
      async def get_users():
          users = await db.fetch_all("SELECT id, name FROM users")
          return users  # Возвращаем нативные типы
      
    • JSON сериализация:

      # Для больших JSON-ответов используйте ujson вместо стандартного
      from fastapi.responses import UJSONResponse
      
      @app.get("/large-data", response_class=UJSONResponse)
      async def get_large_data():
          return {"huge": "dataset"}
      

    4. Неоптимальное использование памяти

    • Загрузка всех данных:

      # Плохо - загружает всё в память
      @app.get("/logs")
      async def get_logs():
          logs = await db.fetch_all("SELECT * FROM logs")  # Миллионы строк!
          return {"logs": logs}
      
      # Хорошо - пагинация
      @app.get("/logs")
      async def get_logs(offset: int = 0, limit: int = 100):
          logs = await db.fetch_all(
              "SELECT * FROM logs ORDER BY id LIMIT $1 OFFSET $2", 
              limit, offset
          )
          return {"logs": logs}
      
    • Избыточные копии данных:

      # Плохо - создает копии данных
      @app.get("/data")
      async def get_data():
          data = await db.fetch_all("SELECT * FROM data")
          # Ненужное копирование!
          processed = [dict(item) for item in data]
          return {"data": processed}
      

    5. Отсутствие кэширования

    • Повторные запросы к БД:

      # Плохо - каждый запрос идет в БД
      @app.get("/config")
      async def get_config():
          return await db.fetch_one("SELECT * FROM config WHERE id = 1")
      
      # Хорошо - с кэшированием
      from fastapi_cache import FastAPICache
      from fastapi_cache.decorator import cache
      
      @app.get("/config")
      @cache(expire=3600)
      async def get_config():
          return await db.fetch_one("SELECT * FROM config WHERE id = 1")
      
    • Отсутствие кэширования вычислений:

      # Плохо - пересчитывается каждый раз
      @app.get("/stats")
      async def get_stats():
          return await compute_expensive_stats()
      
      # Лучше - с периодическим обновлением
      stats_cache = {}
      
      @app.on_event("startup")
      async def init_stats_cache():
          stats_cache["data"] = await compute_expensive_stats()
          asyncio.create_task(update_stats_periodically())
      
      async def update_stats_periodically():
          while True:
              await asyncio.sleep(300)  # Обновление каждые 5 минут
              stats_cache["data"] = await compute_expensive_stats()
      
      @app.get("/stats")
      async def get_stats():
          return stats_cache["data"]
      

    6. Избыточное логирование

    • Логирование в файл в продакшене:
      # Плохо - блокирующий I/O для каждого запроса
      @app.middleware("http")
      async def log_requests(request, call_next):
          with open("access.log", "a") as f:  # Блокирует!
              f.write(f"{request.method} {request.url}\n")
          return await call_next(request)
      
      # Лучше - асинхронный логгер или структурированные логи
      import logging
      logger = logging.getLogger("uvicorn")
      
      @app.middleware("http")
      async def log_requests(request, call_next):
          logger.info(f"{request.method} {request.url}")
          return await call_next(request)
      

    7. Неэффективные HTTP операции

    • Избыточные заголовки и куки:

      # Плохо - много заголовков и большие куки в каждом запросе
      @app.get("/data")
      async def get_data(request: Request):
          # Большая сессионная кука добавляется автоматически
          return {"data": "value"}
      
      # Лучше - минимизировать размер ответа
      @app.get("/data", response_model=DataResponse)
      async def get_data():
          return {"data": "value"}
      
    • Нерациональное использование HTTP-статусов:

      # Плохо - возвращает полную HTML-страницу ошибки
      @app.exception_handler(404)
      async def not_found(request, exc):
          return HTMLResponse(html_content, status_code=404)
      
      # Лучше - минимальный JSON-ответ
      @app.exception_handler(404)
      async def not_found(request, exc):
          return JSONResponse({"error": "Not found"}, status_code=404)
      

    8. Избыточные зависимости

    • Тяжелые зависимости для каждого запроса:
      # Плохо - создание тяжелой зависимости для каждого запроса
      def get_expensive_dependency():
          return ExpensiveClass()  # Инициализируется для каждого запроса!
      
      @app.get("/data")
      async def get_data(dep: ExpensiveClass = Depends(get_expensive_dependency)):
          return dep.process()
      
      # Лучше - синглтон
      expensive_dep = ExpensiveClass()  # Один раз при старте
      
      @app.get("/data")
      async def get_data():
          return expensive_dep.process()
      

    9. Неэффективная валидация

    • Избыточная валидация:
      # Плохо - двойная валидация
      @app.post("/users")
      async def create_user(user_data: dict):
          # Сначала FastAPI валидирует
          user = UserModel(**user_data)  # Затем еще раз Pydantic
          await db.execute("INSERT INTO users VALUES ($1, $2)", user.id, user.name)
          return user
      
      # Лучше - однократная валидация
      @app.post("/users")
      async def create_user(user: UserModel):  # FastAPI уже валидирует
          await db.execute("INSERT INTO users VALUES ($1, $2)", user.id, user.name)
          return user
      

    10. Сборка мусора и утечки памяти

    • Циклические ссылки:

      # Плохо - циклические ссылки
      @app.get("/objects")
      async def get_objects():
          parent = {}
          child = {"parent": parent}
          parent["child"] = child  # Циклическая ссылка!
          # Обработка...
          return {"status": "ok"}
      
    • Кэширование без инвалидации:

      # Постоянно растущий кэш без очистки
      _cache = {}
      
      @app.get("/data/{item_id}")
      async def get_data(item_id: str):
          if item_id not in _cache:
              _cache[item_id] = await fetch_data(item_id)  # Кэш растет бесконечно!
          return _cache[item_id]
      

    Инструменты для профилирования:

    1. py-spy - для отслеживания использования CPU
    2. memory_profiler - для отслеживания использования памяти
    3. pgHero - для анализа запросов PostgreSQL
    4. New Relic/Datadog - для общего мониторинга и обнаружения узких мест

    Ключевой подход: профилируйте, ищите узкие места, оптимизируйте, повторяйте!

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.