Введение: почему таймауты через прокси заслуживают отдельного разговора

Представьте: ваш парсер работает уже третьи сутки, потребляет трафик мобильных прокси, а на выходе — половина пустых записей и логи, забитые словами timeout, connection reset и remote end closed connection. Знакомо? Мы видели десятки таких систем, и почти всегда корень проблемы один: таймауты настроены «на глазок» — одно магическое число вроде 30 секунд на всё сразу. Через прямое соединение это ещё как-то работает. Через прокси, особенно мобильный, — уже нет.

Дело в том, что прокси добавляет в цепочку ещё один участок сети, ещё один набор очередей и ещё один узел, у которого есть собственные таймауты. Запрос проходит не одну фазу ожидания, а пять-шесть, и на каждой можно «зависнуть» по разным причинам. Один общий лимит не различает, где именно застряли: на TCP-рукопожатии с прокси, на установке туннеля к целевому сайту, на медленном первом байте ответа или на передаче большого тела.

Эта статья — про архитектуру ожидания. Мы разберём, из каких фаз состоит HTTP-запрос через прокси, какой таймаут отвечает за каждую фазу, что физически происходит, когда он срабатывает, и как собрать из отдельных лимитов согласованный общий бюджет. Важно сразу отстроиться от смежной темы: здесь мы не обсуждаем коды ответа 429 или 503 и стратегии повторов с экспоненциальной задержкой. Это отдельный слой — реакция на то, что сервер уже ответил. Здесь речь о ситуациях, когда ответа нет вовсе, и о том, как долго мы готовы его ждать на каждом уровне.

После прочтения вы сможете: разложить любой запрос на фазы и назначить каждой свой лимит; объяснить, почему клиент показал таймаут, а сервер всё-таки выполнил действие; правильно согласовать таймауты клиента, пула соединений и самого прокси; и, главное, перестать терять данные и деньги на бесполезном ожидании.

Основы: что такое таймаут и из каких фаз состоит запрос

Таймаут как контракт на ожидание

Таймаут — это максимальное время, которое клиент согласен ждать наступления определённого события, прежде чем признать попытку неудачной и освободить ресурсы. Ключевое слово здесь — определённого. Нет такого понятия как «таймаут запроса вообще». Есть таймаут на установку TCP-соединения, таймаут на TLS-рукопожатие, таймаут на ожидание данных от сокета, таймаут на запись в сокет, таймаут ожидания свободного соединения в пуле и, наконец, общий дедлайн всей операции.

Хорошая аналогия — поездка с пересадками. У вас есть время на дорогу до вокзала, время ожидания поезда, время в пути, время на пересадку. И есть общий лимит: к девяти утра вы должны быть на встрече. Если вы контролируете только общий лимит, вы узнаете о проблеме, когда уже опоздали. Если контролируете каждый этап, вы можете принять решение заранее: например, взять такси, потому что автобус не пришёл за десять минут.

Фазы HTTP-запроса через прямое соединение

Даже без прокси запрос — это последовательность шагов:

  1. Разрешение имени (DNS). Клиент превращает доменное имя в IP-адрес. Обычно занимает от единиц до сотен миллисекунд, но при проблемах с резолвером может висеть секунды.
  2. TCP-соединение. Трёхстороннее рукопожатие: SYN, SYN-ACK, ACK. Требует один полный круговой обход (RTT) до сервера.
  3. TLS-рукопожатие для HTTPS. Ещё один-два круговых обхода в зависимости от версии протокола.
  4. Отправка запроса (write). Заголовки и тело пишутся в сокет. Для маленьких запросов мгновенно, для загрузки файлов — заметное время.
  5. Ожидание первого байта ответа (TTFB). Сервер думает: выполняет запросы к базе, рендерит страницу, ходит в свои микросервисы.
  6. Чтение тела ответа (read). Данные приходят порциями; между порциями бывают паузы.

Что добавляет прокси

Прокси разрывает эту цепочку на две части. Клиент устанавливает соединение с прокси-сервером, а прокси уже сам устанавливает соединение с целевым узлом. Для HTTPS через HTTP-прокси используется метод CONNECT: клиент просит прокси открыть TCP-туннель до хоста и порта, прокси отвечает статусом 200, и только после этого клиент начинает TLS-рукопожатие уже с целевым сервером сквозь туннель. Для SOCKS5 логика аналогична: есть фаза приветствия и аутентификации с прокси, затем команда установить соединение с целью, затем ожидание подтверждения.

Получается расширенный список фаз:

  1. DNS-разрешение адреса прокси (если он задан доменом).
  2. TCP-соединение с прокси.
  3. Аутентификация и команда установить туннель (CONNECT или SOCKS-запрос).
  4. Ожидание, пока прокси разрешит имя целевого хоста и установит с ним TCP-соединение — эта фаза происходит на стороне прокси, но клиент её ждёт.
  5. TLS-рукопожатие с целевым сервером сквозь туннель.
  6. Отправка HTTP-запроса.
  7. Ожидание первого байта ответа.
  8. Чтение тела.

Обратите внимание на четвёртый пункт. Именно здесь кроется главная ловушка мобильных прокси. Сам прокси-сервер обычно стоит в дата-центре, и TCP-соединение до него устанавливается за десятки миллисекунд. Но дальше трафик уходит через сотовый модем, где RTT составляет 40–120 миллисекунд, а при перегруженной базовой станции скачет до полусекунды и выше. Разрешение имени и рукопожатие с целью на этом участке легко занимают одну-две секунды. Клиент, который считает «connect timeout» только до прокси, будет уверен, что соединение установлено мгновенно, а затем упрётся в непонятное ожидание на следующем шаге.

Глубокое погружение: что физически происходит при срабатывании каждого таймаута

Настроить число — полдела. Гораздо важнее понимать, в каком состоянии остаётся система после того, как лимит сработал. Разберём по фазам.

Срабатывание connect timeout

Клиент отправил SYN и не получил SYN-ACK за отведённое время. Операционная система при этом сама повторяет SYN по экспоненциальной схеме: 1, 2, 4, 8 секунд и так далее, суммарно до 60–120 секунд по умолчанию в популярных ядрах. Ваш connect timeout прерывает это ожидание раньше. Сокет закрывается, никаких данных на сервер не ушло, состояние на удалённой стороне не изменилось. Это самый безопасный вид таймаута: повторять такую попытку можно без опасений за идемпотентность.

Через прокси картина чуть сложнее. Если TCP до прокси установлен, а зависла фаза CONNECT, то клиент уже отправил прокси команду и ждёт статус. При срабатывании клиент закрывает сокет к прокси. Прокси заметит закрытие и, как правило, прервёт свою попытку соединиться с целью. Но не всегда мгновенно: некоторые реализации сначала дожидаются собственного upstream-таймаута и только потом освобождают ресурсы. Для клиента это невидимо, но на прокси-сервере накапливаются полуоткрытые соединения, что при массовой нагрузке снижает его пропускную способность.

Важный нюанс: в разных клиентских библиотеках фаза CONNECT учитывается по-разному. В одних она попадает под connect timeout, в других — не покрывается ничем, кроме общего дедлайна запроса. Если у вас нет общего дедлайна, а CONNECT завис, запрос может висеть неограниченно долго. Проверить это несложно: направьте клиент на прокси, который принимает TCP, но не отвечает на CONNECT (такой заглушкой может служить обычный TCP-сервер без логики), и посмотрите, через сколько секунд клиент сдастся.

Срабатывание TLS handshake timeout

TCP-туннель через прокси открыт, клиент отправил ClientHello, а ServerHello не пришёл. Причины: медленный канал модема, потеря пакета на мобильном участке, перегруженный целевой сервер, который принимает TCP, но не успевает обработать TLS. При срабатывании сокет закрывается, HTTP-запрос ещё не отправлен, состояние на сервере не изменилось. Тоже безопасно для повтора.

Практическое наблюдение: через мобильные каналы TLS-рукопожатие — частая точка задержек, потому что требует нескольких круговых обходов подряд, и каждый потерянный пакет добавляет секунду на повторную передачу. При переходе на TLS 1.3 количество обходов уменьшилось, что заметно снизило долю таких таймаутов.

Срабатывание write timeout

Клиент пишет тело запроса в сокет, а буфер отправки заполнен и не освобождается: удалённая сторона не читает или не подтверждает получение. При срабатывании часть данных уже могла уйти на сервер. Если это загрузка файла или отправка формы — сервер мог получить фрагмент. Обычно неполное тело приводит к ошибке разбора на стороне сервера, но для потоковых протоколов и многосоставных загрузок последствия зависят от реализации. Повтор такого запроса требует осторожности.

Срабатывание read timeout

Здесь начинается самое интересное и самое опасное. Запрос отправлен полностью. Клиент ждёт данные, и они не приходят за отведённый интервал. Клиент закрывает сокет и выбрасывает исключение. Но что происходит на другом конце?

Прокси видит, что клиент закрыл соединение. Хороший прокси в этот момент закроет и upstream-соединение к целевому серверу. Но целевой сервер уже получил запрос и уже его обрабатывает. Если это POST, который создаёт заказ, списывает баланс или отправляет сообщение, — действие с высокой вероятностью будет выполнено. Сервер узнает о разрыве только когда попробует записать ответ и получит ошибку. К этому моменту транзакция в базе давно завершена.

Это фундаментальное свойство read timeout: он говорит вам, что вы не дождались ответа, но ничего не говорит о том, выполнилось ли действие. Именно поэтому для неидемпотентных операций read timeout должен обрабатываться иначе, чем connect timeout, и именно поэтому серьёзные API требуют ключи идемпотентности.

Ещё один нюанс — где именно вы застряли. Read timeout срабатывает и при ожидании первого байта (сервер думает), и при паузе между порциями тела (сервер отдаёт данные потоком с задержками). Многие библиотеки трактуют read timeout как интервал бездействия между двумя успешными чтениями из сокета, а не как общее время чтения. Это значит, что ответ размером в сотни мегабайт, приходящий со скоростью один килобайт в секунду, никогда не вызовет read timeout в 10 секунд — данные ведь приходят регулярно. Без общего дедлайна такой запрос может висеть часами.

Что видит прокси и что он возвращает

У прокси есть собственные таймауты, и они порождают другие симптомы. Если прокси не смог соединиться с целью за свой лимит, он вернёт клиенту ответ на CONNECT со статусом 502 или 504 — и с точки зрения клиента это не таймаут, а ошибка прокси. Если прокси ждал ответ от цели и не дождался, он тоже может вернуть 504 Gateway Timeout уже внутри HTTP-ответа (для обычного HTTP без туннеля). А если у прокси есть лимит бездействия на туннеле и он сработал, клиент увидит внезапный разрыв соединения — connection reset или пустой ответ — без всякого таймаута со своей стороны.

Отсюда правило: таймаут клиента должен быть согласован с таймаутами прокси. Если прокси рвёт туннель через 60 секунд бездействия, а ваш read timeout 90 секунд, вы никогда не увидите таймаут — вы будете видеть загадочные обрывы. Если прокси даёт 30 секунд на соединение с целью, а ваш лимит на эту фазу 10 секунд, вы будете сдаваться раньше и не узнаете, что прокси мог бы успеть.

Метод 1: настройка connect timeout с учётом двух хопов

Теория: что покрывает и что должен покрывать

Connect timeout ограничивает установку транспортного соединения. Через прокси это ставит перед нами вопрос: соединение с кем? Формально — с прокси. Практически — нам важно, когда мы получим готовый туннель до цели. Поэтому мы рекомендуем мыслить двумя отдельными лимитами, даже если библиотека даёт один параметр.

Лимит первого хопа — TCP до прокси-сервера. Прокси стоит в дата-центре, RTT до него стабилен. Ориентир: 5–8 RTT, но не менее 2 секунд и не более 5. Если прокси не отвечает на SYN за 3 секунды — он либо перегружен, либо недоступен, и ждать дальше бессмысленно; лучше переключиться на другой адрес из пула.

Лимит второго хопа — время от отправки CONNECT до получения статуса 200. Здесь работает мобильный канал. Ориентир зависит от того, где находится цель, и от качества сотовой сети: типично 3–10 секунд. Мы наблюдали, что 95-й процентиль времени установки туннеля через LTE к популярным сайтам укладывается в 1,5–2,5 секунды, а 99-й — в 4–6 секунд. Ставить лимит ниже 99-го процентиля — значит терять каждый сотый запрос по собственной инициативе.

Как измерить свои значения

  1. Соберите выборку не менее 500 запросов через ваш прокси к целевым хостам в разное время суток.
  2. Логируйте отдельно время до установки TCP с прокси, время до ответа на CONNECT, время TLS-рукопожатия. Большинство клиентов умеют отдавать такие метрики: у curl это переменные time_connect и time_appconnect, у Go — хуки httptrace, у Python-клиентов — события трассировки или замеры вокруг фаз.
  3. Постройте распределение. Вас интересуют p50, p95, p99 и максимум.
  4. Установите лимит на уровне p99 плюс 30–50 процентов запаса. Не на максимуме — выбросы всегда есть, и подстраиваться под них означает держать ресурсы ради единичных аномалий.
  5. Пересматривайте раз в квартал или при смене оператора, региона, тарифа прокси.

Практика в разных клиентах

В Python-библиотеке requests таймаут задаётся кортежем, где первое значение — connect, второе — read. Через прокси первое значение покрывает TCP до прокси и, как правило, ожидание ответа на CONNECT, поскольку туннель устанавливается на том же сокете с тем же лимитом. Пример:

resp = session.get(url, proxies=proxies, timeout=(5, 20))

В httpx есть отдельный объект Timeout с четырьмя полями: connect, read, write и pool. Это самая внятная модель среди Python-клиентов:

timeout = httpx.Timeout(connect=5.0, read=20.0, write=10.0, pool=3.0)

В curl два ключевых флага: --connect-timeout задаёт лимит установки соединения, включая CONNECT и TLS, а --max-time — общий потолок. В Go таймаут набора TCP задаётся через Dialer в Transport, TLS — через TLSHandshakeTimeout, а фаза CONNECT ограничивается контекстом запроса. В Java HttpClient connectTimeout настраивается на билдере клиента, а лимит запроса — на самом запросе. В Node.js через undici есть connectTimeout, headersTimeout и bodyTimeout, плюс AbortSignal для общего дедлайна.

Чек-лист по connect timeout

  • Значение не меньше 2 и не больше 10 секунд для датацентрового и мобильного прокси соответственно.
  • Вы точно знаете, покрывает ли ваш клиент фазу CONNECT этим лимитом.
  • При срабатывании вы переключаетесь на другой прокси из пула, а не бьётесь в тот же.
  • Учтено, что ОС сама ретраит SYN — ваш лимит должен быть короче системного.
  • Для IPv6-хостов включён fallback на IPv4 (Happy Eyeballs), иначе неудачный IPv6-путь съест весь лимит.

Метод 2: read timeout как интервал бездействия и защита первого байта

Две разные задачи под одним именем

Read timeout решает две задачи, и полезно их разделять мысленно, даже если библиотека даёт один параметр.

Ожидание первого байта. Это время работы сервера над вашим запросом. Для статических страниц — десятки миллисекунд. Для поисковой выдачи маркетплейса с фильтрами — от полусекунды до нескольких секунд. Для тяжёлых отчётных API — десятки секунд. Через мобильный прокси к этому добавляется задержка канала на обратном пути.

Пауза между порциями тела. Сервер уже отдаёт данные, но с перерывами: генерирует страницу по частям, стримит результат или просто упирается в узкий канал. Здесь важен не суммарный размер, а максимальная тишина.

Некоторые клиенты имеют раздельные параметры. В Go это ResponseHeaderTimeout для первого байта заголовков и отдельные механизмы для тела. В undici — headersTimeout и bodyTimeout. В большинстве Python-клиентов один read timeout работает как интервал бездействия на любом этапе чтения.

Как выбирать значение

  1. Определите характер целевых ответов. HTML-страница и потоковый JSON требуют разных лимитов.
  2. Измерьте TTFB через ваш прокси. Возьмите p99 и умножьте на 1,5. Для типичного веб-скрапинга через мобильный канал получается 8–15 секунд.
  3. Измерьте максимальную паузу между чанками на выборке успешных ответов. Обычно она в разы меньше TTFB: 1–3 секунды. Если клиент позволяет — задайте bodyTimeout отдельно и жёстче.
  4. Никогда не полагайтесь на read timeout как на защиту от медленной отдачи. Для этого есть общий дедлайн (Метод 4).

Что делать при срабатывании

Здесь возникает главный вопрос: можно ли повторить? Ответ зависит от метода и семантики:

  • GET, HEAD, OPTIONS — повторять можно, состояние сервера не менялось (если сайт не нарушает семантику протокола).
  • PUT с полным телом, DELETE — формально идемпотентны, повтор безопасен.
  • POST без ключа идемпотентности — повтор может создать дубликат. Правильная реакция: не повторять слепо, а сначала проверить состояние другим запросом или пометить операцию как «неизвестный результат» для последующей сверки.
  • POST с ключом идемпотентности — повторять безопасно, сервер вернёт результат первого выполнения.

Мы настоятельно рекомендуем в логах и метриках различать read timeout до первого байта и read timeout в середине тела. Первый чаще указывает на перегрузку целевого сервера или прокси; второй — на проблемы канала. Лечатся они по-разному: в первом случае помогает снижение параллелизма, во втором — смена прокси или региона.

Особенность мобильных каналов

Сотовая сеть работает с переменной задержкой. Модем может на секунду-две «замереть» при переключении между секторами базовой станции или при переходе из режима экономии энергии. С точки зрения клиента это выглядит как тишина в сокете. Если ваш read timeout 2 секунды — вы будете ловить ложные срабатывания несколько раз в час на каждом модеме. Мы наблюдали, что подъём лимита с 3 до 6 секунд снижал долю таймаутов на мобильных прокси в 4–5 раз без заметного роста среднего времени запроса. Секунды простоя на редких запросах обходятся дешевле, чем повторные запросы и потерянный трафик.

Чек-лист по read timeout

  • Значение основано на измеренном p99 TTFB через ваш прокси, а не на интуиции.
  • Вы понимаете, что лимит — это интервал бездействия, а не общее время чтения.
  • Для неидемпотентных запросов при срабатывании нет автоматического повтора без проверки.
  • В метриках разделены таймауты до первого байта и внутри тела.
  • Значение меньше idle-таймаута туннеля на стороне прокси.

Метод 3: write timeout и работа с большими телами запроса

Когда запись вообще может зависнуть

Для большинства запросов тело помещается в один TCP-сегмент и уходит мгновенно — запись завершается ещё до того, как данные физически покинули машину. Write timeout становится значимым в трёх случаях: загрузка файлов, отправка крупных JSON-массивов и любая передача через узкий канал. Мобильный прокси — как раз такой канал в исходящем направлении: типичная скорость отдачи с модема заметно ниже скорости приёма, а буферы на промежуточных узлах ограничены.

Механика такова: клиент вызывает запись, данные попадают в буфер отправки сокета, ядро отправляет их порциями по мере получения подтверждений. Если подтверждения не приходят, буфер заполняется, и следующая запись блокируется. Write timeout ограничивает время такой блокировки.

Три стратегии для больших тел

Стратегия А: общий лимит на запись. Простой подход: один write timeout на весь запрос. Подходит для тел до нескольких мегабайт. Значение выбирается из оценки: размер тела, делённый на минимально приемлемую скорость, плюс запас. Например, 5 мегабайт при минимальной скорости 500 килобайт в секунду — 10 секунд, с запасом — 15.

Стратегия Б: лимит на порцию. Клиент пишет тело чанками и ограничивает время каждой записи. Так работает большинство асинхронных клиентов: write timeout там означает максимальную паузу на отправке одной порции. Значение — 3–10 секунд, вне зависимости от размера файла. Защита от медленной отдачи целиком ложится на общий дедлайн.

Стратегия В: контроль скорости. Клиент отслеживает реальную скорость отдачи и прерывает запрос, если она падает ниже порога на протяжении N секунд. У curl для этого есть пара флагов --speed-limit и --speed-time. Это самый точный инструмент: он различает «медленно, но идёт» и «застряло».

Что происходит при срабатывании

Часть тела уже на сервере. Если вы загружали файл в одном запросе — сервер получит обрезанное тело. Для protokol multipart это чаще всего приведёт к ошибке разбора и отказу целиком, что безопасно. Для API с поддержкой возобновляемых загрузок (tus, чанковые протоколы облачных хранилищ) правильная реакция — запросить у сервера смещение и продолжить с него. Именно возобновляемые загрузки мы рекомендуем для любых тел свыше 10 мегабайт через мобильные прокси: одиночный длинный запрос через сотовый канал слишком уязвим к обрывам.

Пошаговая настройка для загрузок через прокси

  1. Оцените медианную и минимальную скорость отдачи через ваш прокси. Загрузите тестовый файл 5–10 мегабайт двадцать раз в разное время.
  2. Если разброс скорости более чем трёхкратный — используйте Стратегию Б или В, а не общий лимит.
  3. Разбейте большие файлы на части 1–5 мегабайт, если целевой сервис это поддерживает.
  4. Установите write timeout на порцию 5–10 секунд.
  5. Обязательно дополните общим дедлайном на весь запрос, рассчитанным из размера и минимальной скорости.
  6. При срабатывании — определяйте, что именно сервер успел получить, а не повторяйте всё с начала.

Метод 4: общий бюджет запроса и распространение дедлайна

Почему сумма частных лимитов — это ещё не бюджет

Допустим, вы выставили connect 5, TLS 5, write 10, read 15 секунд. Кажется, что запрос не может длиться больше 35 секунд. Но read timeout — интервал бездействия. Ответ, приходящий по одному килобайту каждые 14 секунд, никогда его не нарушит. Запрос в 10 мегабайт при таком темпе займёт почти сутки. Без общего лимита ваши воркеры будут заняты бесконечно, пул соединений исчерпается, и система встанет — при том что ни один частный таймаут не сработал.

Общий бюджет (deadline, total timeout) — это абсолютный потолок для всей операции от первого системного вызова до последнего прочитанного байта. Он не заменяет частные лимиты, а дополняет их: частные лимиты дают быструю и точную диагностику, общий — гарантию завершения.

Как рассчитать бюджет

Идём сверху вниз, а не снизу вверх. Начните с вопроса: какое максимальное время ожидания одного результата приемлемо для бизнес-задачи? Для интерактивного сценария (пользователь ждёт) — 3–10 секунд. Для фонового парсинга — 30–60 секунд. Для загрузки крупных файлов — рассчитывается от размера.

Затем этот бюджет распределяется по фазам с учётом измеренных распределений:

  • Установка туннеля через прокси (TCP плюс CONNECT плюс TLS): типично 15–25 процентов бюджета.
  • Запись запроса: 5–10 процентов для обычных запросов.
  • Ожидание первого байта: 30–40 процентов.
  • Чтение тела: остаток.

Пример: бюджет 30 секунд для парсинга через мобильный прокси. Connect (включая CONNECT) 6 секунд, TLS 4 секунды, write 3 секунды, read как интервал бездействия 10 секунд, общий дедлайн 30 секунд. Сумма частных лимитов 23 секунды меньше бюджета — это нормально, они срабатывают по отдельности. Общий дедлайн ловит случаи медленной отдачи, которые не поймает ни один частный.

Распространение дедлайна через цепочку

В распределённых системах запрос редко бывает одиночным. Ваш сервис получил задачу с лимитом 30 секунд, потратил 4 секунды на подготовку, затем идёт через прокси к целевому сайту. Сколько времени у HTTP-запроса? Не 30, а 26 секунд минус запас на обработку ответа. Это и есть распространение дедлайна: каждый последующий вызов получает не фиксированный таймаут, а остаток бюджета.

В Go это реализуется контекстом с дедлайном, который передаётся в запрос. В Python — через asyncio с явной передачей оставшегося времени. В Java — через вычисление Duration перед каждым вызовом. Правило одно: таймаут на HTTP-запрос вычисляется динамически, как минимум из статического лимита и оставшегося бюджета.

Без этого возникает классическая проблема: верхний уровень уже отказался ждать и вернул ошибку, а нижний ещё десять секунд держит соединение через прокси и потребляет трафик ради результата, который никому не нужен. При платном трафике мобильных прокси это буквально сжигание денег.

Пул соединений и его собственные таймауты

Ещё два лимита, о которых часто забывают. Pool timeout — сколько ждать свободного соединения из пула, если все заняты. Если он не задан, при всплеске нагрузки запросы будут ждать неограниченно, и внешне это выглядит как зависание клиента. Ставьте 1–3 секунды: если за это время соединение не освободилось, система перегружена и лучше отказать сразу.

Idle timeout соединения в пуле — сколько неиспользуемое keep-alive-соединение хранится перед закрытием. Здесь критично согласование с прокси. Если прокси закрывает бездействующее соединение через 60 секунд, а ваш пул хранит его 90 секунд, то на 61-й секунде вы возьмёте из пула мёртвый сокет, отправите в него запрос и получите connection reset — не таймаут, а разрыв. Многие библиотеки прозрачно повторяют запрос в такой ситуации, но только для идемпотентных методов. Правило: idle timeout клиента строго меньше idle timeout прокси, с запасом хотя бы 10–20 процентов.

Фреймворк «бюджет сверху вниз»

  1. Зафиксируйте бизнес-ограничение на время ожидания результата.
  2. Вычтите время на собственную обработку и запас на повтор, если он предусмотрен.
  3. Полученный остаток — общий дедлайн HTTP-запроса.
  4. Распределите его по фазам согласно измеренным p99 каждой фазы через ваш прокси.
  5. Проверьте, что каждый частный лимит меньше соответствующего лимита на стороне прокси.
  6. Задайте pool timeout и idle timeout пула, согласованные с прокси.
  7. Реализуйте передачу остатка бюджета во вложенные вызовы.
  8. Логируйте, какой именно лимит сработал, и время, потраченное на каждую фазу.

Метод 5: наблюдаемость таймаутов и адаптивная настройка

Без измерений нет настройки

Все предыдущие методы упираются в одно: вы должны знать реальные распределения времени по фазам через ваш прокси. Единственный способ узнать — измерять постоянно. Современные клиенты предоставляют хуки трассировки: момент начала DNS, установления TCP, получения ответа на CONNECT, завершения TLS, отправки запроса, первого байта, последнего байта. Соберите эти события в метрики с разбивкой по прокси, целевому хосту и типу ошибки.

Какие метрики собирать

  • Гистограммы длительности каждой фазы, отдельно по прокси-эндпоинту и оператору.
  • Доля срабатываний каждого типа таймаута от общего числа запросов.
  • Доля таймаутов до первого байта против внутри тела.
  • Доля разрывов соединения без таймаута (признак несогласованных idle-лимитов).
  • Среднее время, потраченное на запросы, завершившиеся таймаутом — это ваш прямой убыток в трафике и ресурсах.

Адаптивные таймауты

Тренд последних лет, который к 2026 году стал стандартом в зрелых системах, — адаптивные лимиты. Вместо статического числа клиент поддерживает скользящее окно наблюдений по каждой паре прокси-цель и выставляет таймаут как p99 окна с коэффициентом запаса, ограниченный сверху и снизу разумными границами. Когда канал ухудшается, лимит растёт и ложных срабатываний становится меньше. Когда канал восстанавливается, лимит снижается и система быстрее реагирует на реальные проблемы.

Реализация несложна: кольцевой буфер на 200–500 последних измерений на ключ, пересчёт квантиля раз в несколько секунд, границы вида «не меньше 3 и не больше 20 секунд для read». Важно защититься от деградации: если все запросы начинают таймаутить, окно наполняется значениями на уровне лимита, и лимит будет только расти. Поэтому в окно попадают лишь успешные запросы, а рост лимита ограничен верхней границей.

Хеджированные запросы

Для чтения через пул из нескольких прокси есть приём, снижающий влияние медленных хвостов без роста таймаутов: если запрос не завершился за p95 времени, отправить дубликат через другой прокси и взять первый пришедший ответ. Это увеличивает трафик на несколько процентов, но радикально уменьшает p99 латентности. Подходит только для идемпотентных запросов и требует аккуратной отмены проигравшего дубликата, чтобы не расходовать трафик впустую.

Типичные ошибки: что не нужно делать

Одно число на всё

Самая распространённая ошибка. Единый таймаут 30 секунд означает, что мёртвый прокси вы будете обнаруживать полминуты, а медленный ответ в середине тела не обнаружите никогда. Разделяйте фазы.

Отсутствие таймаутов по умолчанию

Несколько популярных библиотек не имеют таймаутов из коробки: запрос может висеть бесконечно. В requests это так до сих пор. Любой вызов без явного таймаута через прокси — это потенциально навечно заблокированный воркер.

Read timeout больше idle-лимита прокси

Вы не увидите таймауты, вы увидите разрывы соединений и будете искать проблему не там. Узнайте лимиты своего прокси-провайдера и настройте клиента строго ниже.

Слепой повтор после read timeout на POST

Прямой путь к дубликатам заказов, двойным списаниям и повторным сообщениям. После read timeout на неидемпотентном запросе результат неизвестен — с ним надо разбираться, а не гадать.

Игнорирование фазы CONNECT

Считать, что connect timeout покрывает установку туннеля, не проверив это в документации конкретной библиотеки. В некоторых клиентах фаза CONNECT висит до общего дедлайна, а если его нет — бесконечно.

Подгонка под максимум

Увидели один запрос за 45 секунд — поставили лимит 60. Теперь каждая реальная проблема стоит вам минуту ожидания. Ориентируйтесь на p99 с запасом, а выбросы отдавайте механизму повтора или хеджирования.

Таймаут без отмены нижележащей работы

Верхний уровень бросил исключение по своему лимиту, а HTTP-запрос продолжает жить в фоновой задаче. Особенно частая ошибка в асинхронном коде: обёртка с ожиданием отработала, а корутина не отменена. Убедитесь, что срабатывание таймаута приводит к реальному закрытию сокета.

Одинаковые лимиты для датацентровых и мобильных прокси

Разница в задержке и джиттере между ними — в разы. Профиль, работающий на серверном прокси, на мобильном даёт шквал ложных таймаутов. Держите отдельные профили настроек.

Отсутствие pool timeout

При всплеске нагрузки запросы бесконечно ждут свободного соединения. Внешне — зависание всего клиента при нулевом сетевом трафике.

Инструменты и ресурсы

Диагностика из командной строки

curl остаётся эталонным инструментом для разбора фаз. Флаги --connect-timeout, --max-time, --speed-limit, --speed-time покрывают все уровни, а формат вывода -w с переменными времени показывает, сколько заняла каждая фаза:

curl -x http://user:pass@proxy:port --connect-timeout 5 --max-time 30 -o /dev/null -s -w "dns=%{time_namelookup} tcp=%{time_connect} tls=%{time_appconnect} ttfb=%{time_starttransfer} total=%{time_total}" https://example.com/

Обратите внимание: через прокси переменная time_connect показывает время до прокси, а time_appconnect — до завершения TLS с целью, то есть включает CONNECT. Разница между ними — ваш второй хоп.

Клиентские библиотеки и их модели таймаутов

  • Python requests: кортеж (connect, read). Нет write и общего таймаута; общий реализуется внешней обёрткой или отменой на уровне потока.
  • Python httpx: объект Timeout с connect, read, write, pool. Общего нет, но в асинхронном режиме легко добавляется через ожидание с лимитом и отменой.
  • Python aiohttp: ClientTimeout с полями total, connect, sock_connect, sock_read. Единственный из популярных Python-клиентов с встроенным общим лимитом.
  • Go net/http: Dialer.Timeout, TLSHandshakeTimeout, ResponseHeaderTimeout, ExpectContinueTimeout, IdleConnTimeout на транспорте; Client.Timeout как общий; контекст запроса как динамический дедлайн.
  • Java HttpClient: connectTimeout на клиенте, timeout на запросе (покрывает до получения заголовков). Чтение тела ограничивается на уровне BodyHandler или обёрткой.
  • Node.js undici: connectTimeout, headersTimeout, bodyTimeout, keepAliveTimeout; общий — через AbortSignal.timeout.

Анализ трафика

tcpdump и Wireshark позволяют увидеть, что реально происходило на проводе: ушёл ли SYN, пришёл ли SYN-ACK, кто первым отправил FIN или RST. Это единственный способ достоверно ответить на вопрос «кто разорвал соединение — я, прокси или сервер». Для HTTPS-содержимого видимость ограничена, но фазы соединения и туннеля видны полностью.

Стенды для воспроизведения

Для проверки поведения клиента при зависаниях полезно иметь набор заглушек: TCP-сервер, который принимает соединение и молчит (проверка connect и CONNECT); HTTP-сервер, который отвечает заголовками и затем молчит (проверка read до тела); сервер, отдающий байт в секунду (проверка общего дедлайна). Написать такие заглушки — полчаса работы, а сэкономленное время на отладке в продакшене измеряется днями. Также существуют инструменты сетевой эмуляции, позволяющие добавить задержку, джиттер и потери на интерфейсе, чтобы имитировать мобильный канал в лаборатории.

Наблюдаемость

Стандартом стал сбор метрик и трассировок в формате OpenTelemetry с автоматической инструментацией HTTP-клиентов. Гистограммы по фазам, атрибуты с идентификатором прокси и типом сработавшего лимита — минимальный набор, без которого настройка превращается в гадание.

Кейсы и результаты

Кейс 1: парсинг маркетплейса через мобильные прокси

Команда собирала карточки товаров через пул мобильных прокси. Исходная конфигурация: единый таймаут 15 секунд, без общего дедлайна, стандартный пул соединений. Симптомы: 11 процентов запросов завершались ошибками, из них две трети — таймауты, треть — разрывы соединения. Средняя длительность неудачного запроса — 14 секунд, то есть каждый десятый запрос съедал время и трафик впустую.

Диагностика по фазам показала: p99 установки туннеля — 4,8 секунды, p99 TTFB — 6,2 секунды, максимальная пауза между чанками у успешных ответов — 2,1 секунды, idle-лимит туннеля у провайдера — 60 секунд, а пул клиента хранил соединения 120 секунд.

Изменения: connect 7 секунд с покрытием CONNECT, read 9 секунд, write 5 секунд, общий дедлайн 25 секунд, idle пула 45 секунд, pool timeout 2 секунды. Разделение таймаутов до первого байта и внутри тела в метриках.

Результат через неделю: общая доля ошибок снизилась до 3,4 процента, разрывы соединений исчезли практически полностью, средняя длительность неудачного запроса упала до 8 секунд. Расход трафика на единицу собранных данных сократился на 19 процентов. Никаких изменений в логике повторов не делалось — только таймауты.

Кейс 2: интеграция с платёжным API и дубликаты

Сервис отправлял POST-запросы на создание платёжных операций через корпоративный прокси. Read timeout 10 секунд и автоматический повтор при любом исключении. Раз в несколько дней возникали дубликаты операций. Анализ показал: целевой API в моменты нагрузки отвечал за 11–14 секунд, клиент отваливался по read timeout, повторял запрос, и обе операции успешно выполнялись.

Решение состояло из трёх частей: read timeout поднят до 20 секунд на основании измеренного p99 в 15 секунд; повтор после read timeout на POST заменён на запрос статуса операции по клиентскому идентификатору; введён ключ идемпотентности в заголовке, который поддерживал API. Дубликаты прекратились полностью. Отдельный вывод команды: read timeout на неидемпотентном запросе — это не ошибка, а состояние «результат неизвестен», требующее отдельной ветки обработки.

Кейс 3: загрузка медиафайлов через мобильный канал

Приложение загружало видео объёмом 50–200 мегабайт через мобильные прокси одним запросом. Write timeout 30 секунд, общего дедлайна нет. Симптомы: около 8 процентов загрузок обрывались, каждая неудача означала повтор с нуля, суточный перерасход трафика достигал десятков гигабайт.

Переход на чанковую загрузку по 4 мегабайта с возобновлением, write timeout на чанк 8 секунд, контроль минимальной скорости 100 килобайт в секунду на протяжении 10 секунд, общий дедлайн на чанк 60 секунд. Доля полностью проваленных загрузок упала до 0,3 процента, перерасход трафика на повторы сократился в 12 раз, потому что повторялся только последний неудачный чанк.

Кейс 4: зависание CONNECT без общего дедлайна

Асинхронный сборщик на одной из Python-библиотек периодически «застывал»: воркеры живы, сеть молчит, очередь не двигается. Через час-два сборщик перезапускали вручную. Разбор показал: часть прокси в пуле принимала TCP, но не отвечала на CONNECT. В используемой конфигурации эта фаза не была покрыта ни одним лимитом. Добавление общего дедлайна на весь запрос и явного лимита на установку туннеля устранило зависания. Дополнительно добавлен healthcheck прокси с проверкой именно CONNECT-фазы, а не только TCP-доступности.

FAQ: сложные вопросы о таймаутах через прокси

Чем таймаут клиента отличается от ответа 504 от прокси?

Таймаут клиента — это ваше решение перестать ждать; прокси и сервер о нём узнают только по закрытию соединения. Ответ 504 — это решение прокси: он сам не дождался целевого сервера и сообщил вам об этом полноценным HTTP-ответом. В первом случае сокет закрывается с исключением, во втором вы получаете нормальный ответ с кодом ошибки. Обрабатывать их надо по-разному: 504 означает, что прокси точно жив и проблема ниже по цепочке; клиентский таймаут ничего не говорит о том, где именно застряло.

Почему через мобильный прокси нужны более длинные таймауты, чем через датацентровый?

Из-за джиттера. Средняя задержка сотового канала не так велика, но её разброс огромен: переключения между секторами, режимы энергосбережения модема, конкуренция за радиоресурс. Таймаут настраивается по хвосту распределения, а хвост у мобильного канала в несколько раз длиннее. При этом слишком длинные лимиты тоже вредны — они замедляют обнаружение реально мёртвых прокси. Баланс достигается измерением p99 и запасом в 30–50 процентов, а не удвоением всех чисел.

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

Три способа. Первый — по времени: если исключение пришло через время, равное connect timeout, а не read, вы знаете фазу. Второй — через хуки трассировки: если событие «TLS завершён» было, а «первый байт» — нет, застряли на TTFB. Третий — по тексту и типу исключения: многие библиотеки различают ConnectTimeout и ReadTimeout как отдельные классы. Мы рекомендуем всегда логировать, какие фазы успели завершиться до исключения — это превращает загадочный таймаут в точный диагноз.

Можно ли повторять запрос после срабатывания write timeout?

Для GET без тела — да, ничего не ушло. Для POST с телом — только если вы уверены, что сервер отвергает неполные тела. Большинство серверов так и делают: неполный JSON или обрезанный multipart вызывают ошибку разбора. Но потоковые API, которые начинают обработку по мере получения данных, могут частично применить изменения. Если сомневаетесь — проверяйте состояние перед повтором.

Как согласовать таймауты клиента с таймаутами прокси-провайдера?

Запросите у провайдера или найдите в документации три значения: лимит на соединение с целевым хостом, idle-лимит туннеля и максимальное время жизни соединения. Ваш лимит на установку туннеля должен быть не меньше провайдерского (иначе вы сдаётесь раньше, чем прокси мог бы успеть), а ваш read timeout и idle пула — строго меньше провайдерских idle-лимитов. Если документации нет, измерьте эмпирически: откройте соединение, помолчите N секунд, попробуйте отправить запрос, найдите порог, после которого приходит разрыв.

Нужен ли общий дедлайн, если все частные лимиты настроены?

Да, обязательно. Частные лимиты не ограничивают суммарное время: медленная отдача тела по одному килобайту с интервалом меньше read timeout может длиться неограниченно. Общий дедлайн — единственная гарантия, что воркер освободится. Кроме того, при распространении бюджета через цепочку вызовов именно общий дедлайн передаётся вниз, а частные лимиты остаются локальной настройкой.

Как влияют HTTP/2 и HTTP/3 на модель таймаутов через прокси?

HTTP/2 мультиплексирует много запросов в одно соединение, поэтому read timeout на уровне сокета перестаёт быть таймаутом одного запроса: сокет получает данные других потоков, и бездействие конкретного запроса не заметно. Нужны лимиты на уровне потока — большинство HTTP/2-клиентов их предоставляют через дедлайн запроса. HTTP/3 поверх QUIC меняет и фазу соединения: рукопожатие совмещено с криптографическим, и connect timeout покрывает оба. Через классический CONNECT-прокси HTTP/3 к цели, как правило, не проходит — туннель TCP-ориентирован, и клиент откатывается на HTTP/2 или HTTP/1.1. Расширения для UDP-туннелирования через прокси развиваются, но на 2026 год в массовых клиентах их поддержка ограничена.

Что делать, если после таймаута соединение возвращается в пул и следующий запрос падает?

Это признак того, что клиент не закрыл сокет корректно или пул не пометил соединение как испорченное. Соединение, на котором сработал read timeout, нельзя переиспользовать: в нём могут находиться байты запоздавшего ответа, которые будут прочитаны как ответ на следующий запрос. Убедитесь, что ваш клиент при таймауте закрывает соединение, а не возвращает в пул. В хорошо спроектированных клиентах это поведение по умолчанию, но при собственных обёртках и низкоуровневой работе с сокетами ошибка встречается регулярно.

Как настроить таймауты для SOCKS5-прокси в отличие от HTTP-прокси?

Принцип тот же, отличаются фазы: вместо CONNECT — приветствие, аутентификация и команда соединения, это два-три круговых обхода до прокси плюс время соединения прокси с целью. В большинстве клиентов SOCKS-рукопожатие целиком попадает под connect timeout. Убедитесь, что значение учитывает не только TCP до прокси, но и время установки соединения прокси с целью через мобильный канал — те же 3–10 секунд.

Заключение: таймауты как инженерная дисциплина

Давайте подведём итог. HTTP-запрос через прокси — это не одна операция, а цепочка из семи-восьми фаз ожидания, каждая со своей природой задержек и своими последствиями при обрыве. Connect и TLS-таймауты безопасны: ничего не ушло на сервер, можно пробовать снова. Write timeout оставляет сервер с неполными данными. Read timeout — самый коварный: запрос доставлен и, возможно, выполнен, а вы этого не знаете. Общий дедлайн не заменяет частные лимиты, а страхует от медленной отдачи, которую они не ловят.

Через мобильные прокси всё это усиливается: второй хоп проходит по каналу с высоким джиттером, и лимиты, отлаженные на серверных прокси, дают шквал ложных срабатываний. Единственный способ настроить их правильно — измерять распределения по фазам через ваш конкретный прокси и ставить лимиты по p99 с запасом, согласовывая их с лимитами самого прокси.

Ваши следующие шаги:

  1. Найдите в своём коде каждый HTTP-вызов через прокси и проверьте, есть ли у него явные таймауты на все фазы и общий дедлайн.
  2. Выясните, покрывает ли ваш клиент фазу CONNECT и как он трактует read timeout — как бездействие или как общее время.
  3. Узнайте idle-лимиты и лимиты соединения вашего прокси-провайдера и приведите настройки клиента в соответствие.
  4. Включите трассировку фаз и соберите распределения за неделю.
  5. Пересчитайте лимиты по p99, разделите профили для датацентровых и мобильных прокси.
  6. Разделите обработку таймаутов для идемпотентных и неидемпотентных запросов.
  7. Добавьте в метрики тип сработавшего лимита и фазу, на которой он сработал.

Таймауты — это не параметр, который выставляют один раз и забывают. Это часть контракта вашей системы с внешним миром, и как любой контракт она требует измерений, пересмотра и согласования сторон. Сделайте это один раз системно — и вы удивитесь, насколько тише станут ваши логи и насколько дешевле — ваш трафик.