Как понять, где именно происходит сбой: приложение, сервер, база или сеть

 

 

 

 

 

/ 01. ВХОДНЫЕ ДАННЫЕ

Система работает. Бизнес уже теряет время.

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

10:07. На производственном предприятии сотрудники начинают сообщать, что проведение складских документов занимает значительно больше обычного. Некоторые операции завершаются через несколько секунд, другие ждут ответа почти минуту, а часть заканчивается ошибкой по таймауту.

При этом система формально доступна. Пользователи входят в неё, открывают справочники, просматривают остатки. Сервер не выключен, PostgreSQL принимает соединения, прикладные службы запущены.

Первое, что видит дежурный инженер, не похоже на классическую аварию:

  • загрузка процессора приложения — около 35%;
  • загрузка процессора сервера базы данных — около 40%;
  • свободная оперативная память есть;
  • соединения с PostgreSQL устанавливаются;
  • ошибок массового отказа в журналах нет;
  • время проведения документов выросло с обычных 0,5–1,5 секунды до 15–40 секунд.

* Все числа в этом расследовании иллюстративные: они нужны, чтобы показать ход диагностики, а не описывают конкретный инцидент LOG-AI.

Первое искушение — увеличить таймауты. Второе — добавить ресурсов серверу. Третье — перезапустить приложение и посмотреть, поможет ли.

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

В данном случае особенно опасно то, что система не отказала полностью. Она продолжает обрабатывать запросы, но делает это неравномерно. Часть операций проходит нормально, часть задерживается, а новые запросы постепенно накапливаются.

Для бизнеса это часто хуже очевидного отказа. При полном отказе понятно, что работа остановлена. При деградации сотрудники могут повторять действия и запускать операции повторно. Если приложение не предотвращает дублирование запросов, дополнительная нагрузка способна усилить первоначальное замедление.

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

Что известно до начала расследования

Сначала инженер фиксирует наблюдаемые факты, отделяя их от предположений.

Известно, что проблема началась около 10:07. Она затрагивает проведение складских документов, но не все операции в системе. PostgreSQL доступен. Массового роста загрузки CPU нет. Пользователи получают как длительные ответы, так и таймауты.

Пока неизвестно:

  • выполняются ли медленные SQL-запросы или ожидают начала выполнения;
  • есть ли блокировки и долгие транзакции;
  • не исчерпан ли пул соединений приложения;
  • не выросло ли время ожидания внешнего сервиса;
  • связана ли проблема с недавним изменением приложения.

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

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

Правило расследования: сначала фиксируем симптомы и временные границы, затем проверяем гипотезы. Не подменяем наблюдения догадками.

[ DIAGRAM // DEGRADATION_CASCADE_RETRY_EFFECT ]
ПЕРВИЧНЫЙ ЗАПРОСДокумент ждет ответаЗадержка: 15-40сЛАВИНА ПОВТОРОВСотрудники кликаютповторно по кнопкеТУПИК В СУБДОчередь растет,CPU ~40% (Норма)ОПАСНОСТЬ:Система остаётся доступной, но задержки и повторные запросы увеличивают нагрузку и усиливают деградацию.

 

/ 02. ПУТЬ ЗАПРОСА

На каком этапе пользователь теряет время

Пользователь видит одну операцию: нажал кнопку, дождался результата. Внутри системы эта операция может включать десятки обращений к другим компонентам.

В нашем случае путь выглядит так:

Клиент 1С → прикладной сервер → обработчик проведения документа → пул соединений → PostgreSQL → результат операции → клиент.

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

Пока неизвестно, где именно возникает задержка.

Предположим, сотрудник ждёт 30 секунд. Это не означает, что PostgreSQL 30 секунд выполнял вычисления. База могла потратить 200 мс на запрос и ещё 29,8 секунды ждать освобождения блокировки. Либо приложение могло 20 секунд ожидать соединение, после чего база обработала запрос за 100 мс.

Поэтому первое техническое действие — разложить общее время на измеряемые этапы.

Разложение времени выполнения запроса по этапам:

ЭТАП 01
Обработка запроса приложением до обращения к БД
Норма: 80 мс
Сбой: 100 мс
ЭТАП 02
Ожидание соединения
Норма: 10 мс
Сбой: 900 мс
ЭТАП 03 // КРИТИЧЕСКИЙ
Выполнение и ожидание SQL
Норма: 250 мс
Сбой: 24 000 мс
ЭТАП 04
Завершение операции и формирование ответа
Норма: 160 мс
Сбой: 300 мс
ОБЩЕЕ ВРЕМЯ ОПЕРАЦИИ: Норма: 500 мс | Сбой: ~25.3 с

* Это пример согласованного разложения времени, а не универсальная схема измерений. В реальной системе интервалы могут включать вложенные операции или выполняться параллельно. Нельзя складывать метрики, если их интервалы перекрываются.

В примере основная задержка находится внутри этапа взаимодействия с базой. Но даже здесь рано заключать, что PostgreSQL не справляется с запросами.

Нужно разделить два состояния:

  • База выполняет запрос, расходуя время на чтение данных, вычисления, сортировку и другие операции.
  • Запрос ждёт ресурс: блокировку, завершение другой транзакции, ввод-вывод или иной этап выполнения.

Разница принципиальная. В первом случае нужно исследовать объём работы и план выполнения. Во втором — причину ожидания.

Если у системы нет трассировки

В старой корпоративной системе полноценная распределённая трассировка может отсутствовать. Это не повод останавливаться.

Можно сопоставить журналы приложения, технологический журнал 1С, журналы PostgreSQL и системные метрики по временным отметкам, идентификаторам сеансов и другим доступным признакам.

В технологическом журнале 1С особенно полезны события, позволяющие установить длительность серверных вызовов, обращений к СУБД и других значимых операций.

Конкретные события и параметры регистрации выбирают в зависимости от версии платформы и задачи расследования. Для каждого источника нужно понимать, что именно измеряется. Длительность события обращения к СУБД на уровне 1С не всегда равна чистому времени выполнения SQL: в неё могут входить дополнительные ожидания на пути взаимодействия.

Если сопоставить данные невозможно, это отдельный недостаток наблюдаемости, который следует устранить после инцидента.

Но в нашем случае доступ к диагностическим данным PostgreSQL есть. Начнём с него.

[ DIAGRAM // LATENCY_DISTRIBUTION_BREAKDOWN ]
НОРМА (500 мс)Прил.SQL (250мс)ОтветСБОЙ (~25.3 с)Прил.КРИТИЧЕСКАЯ ЗАДЕРЖКА: Выполнение и ожидание SQL (24 000 мс)ОтветОколо 95% времени операции приходится на взаимодействие с СУБД. Задача — локализовать причину задержки.

 

/ 03. POSTGRESQL

Проверяем не загрузку сервера, а состояние конкретных запросов

PostgreSQL предоставляет системное представление pg_stat_activity, в котором можно увидеть активность серверных процессов, состояние соединений, выполняемые запросы и некоторые виды ожиданий.

Первый запрос должен ответить на три вопроса:

  • Какие запросы выполняются необычно долго?
  • Какие из них ожидают блокировку?
  • Есть ли транзакции, которые продолжаются значительно дольше обычного?

Для начала выполним диагностический запрос:

SELECT
    a.pid,
    a.usename,
    a.application_name,
    a.client_addr,
    a.state,
    now() - a.query_start AS query_age,
    now() - a.xact_start AS transaction_age,
    a.wait_event_type,
    a.wait_event,
    pg_blocking_pids(a.pid) AS blocking_pids,
    left(a.query, 500) AS query_text
FROM pg_stat_activity AS a
WHERE a.datname = current_database()
  AND a.pid <> pg_backend_pid()
  AND (
      cardinality(pg_blocking_pids(a.pid)) > 0
      OR (
          a.state = 'active'
          AND a.query_start < now() - interval '2 seconds'
      )
      OR (
          a.state = 'idle in transaction'
          AND a.xact_start < now() - interval '10 seconds'
      )
  )
ORDER BY
    a.xact_start NULLS LAST,
    a.query_start NULLS LAST;

Пороговые значения в две и десять секунд выбраны только для примера. В рабочей системе их нужно подбирать с учётом нормальной длительности операций. Для некоторых пакетных заданий десять секунд — совершенно обычное время.

Запрос показывает кандидатов на расследование, а не автоматически определяет неисправность.

Важно правильно читать результат.

  • query_age — время с момента начала текущего или последнего запроса, если соответствующая временная отметка доступна. Для неактивного соединения это не продолжительность текущей работы.
  • transaction_age — время с начала текущей транзакции.
  • wait_event_type и wait_event помогают понять, ожидает ли активный процесс определённое событие.
  • blocking_pids содержит идентификаторы процессов, блокирующих данный процесс, если такие блокировки есть.
  • state = 'idle in transaction' означает, что соединение сейчас не выполняет запрос, но транзакция остаётся открытой.

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

При этом idle in transaction само по себе не доказывает ошибку. Важно, как долго длится транзакция, какие ресурсы она удерживает и влияют ли они на другие операции.

Для просмотра активности необходимы соответствующие права. Видимость текстов запросов и сведений о других сессиях зависит от версии PostgreSQL и предоставленных привилегий. В некоторых случаях потребуется роль с правами мониторинга. Перед передачей результатов следует учитывать, что текст SQL может содержать чувствительные данные.

Что обнаружили

В нашем иллюстративном случае несколько запросов проведения документов находятся в состоянии ожидания блокировки.

У них растёт время выполнения, но CPU базы остаётся умеренным. В столбце wait_event_type отображается Lock, а blocking_pids указывает на один и тот же процесс.

Это первая существенная зацепка. Медленные операции связаны не просто с большим объёмом вычислений: по крайней мере часть из них ждёт освобождения блокировки.

Теперь необходимо найти блокирующий процесс и понять, почему он удерживает ресурс.

Как найти блокирующую транзакцию

Запрос ориентирован на ожидающие сессии текущей базы данных. Для диагностики блокировок, связанных с подготовленными транзакциями или другими межсессионными сценариями, может потребоваться отдельная проверка:

SELECT
    waiting.pid AS waiting_pid,
    waiting.application_name AS waiting_app,
    waiting.state AS waiting_state,
    now() - waiting.query_start AS waiting_query_age,
    waiting.wait_event_type,
    waiting.wait_event,
    left(waiting.query, 300) AS waiting_query,

    blocker.pid AS blocker_pid,
    blocker.application_name AS blocker_app,
    blocker.usename AS blocker_user,
    blocker.client_addr AS blocker_client,
    blocker.state AS blocker_state,
    now() - blocker.xact_start AS blocker_transaction_age,
    blocker.query_start AS blocker_query_start,
    left(blocker.query, 500) AS blocker_query

FROM pg_stat_activity AS waiting
CROSS JOIN LATERAL
    unnest(pg_blocking_pids(waiting.pid)) AS b(blocker_pid)
JOIN pg_stat_activity AS blocker
    ON blocker.pid = b.blocker_pid
WHERE waiting.datname = current_database()
ORDER BY waiting.query_start NULLS LAST;

Здесь есть важная тонкость: блокирующий процесс не обязательно выполняет запрос в момент проверки.

Он может находиться в состоянии idle in transaction. Последний SQL уже завершился, но транзакция ещё не закрыта, поэтому блокировка сохраняется.

В такой ситуации blocker_query показывает последний запрос, а не обязательно текущую выполняемую операцию. Время с начала транзакции информативнее времени последнего запроса.

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

Именно такой результат мы получаем в нашем расследовании.

Несколько операций проведения документов ожидают один процесс. Этот процесс находится в состоянии idle in transaction, а его транзакция открыта значительно дольше, чем обычно.

Теперь проблема локализована гораздо точнее: нужно выяснить, почему приложение оставляет транзакцию открытой.

Но прежде чем делать вывод, проверим, не существует ли другой причины, которая одновременно объясняет эти симптомы.

[ DIAGRAM // POSTGRESQL_BLOCKING_CHAIN_ACTIVITY ]
БЛОКИРУЮЩИЙ ПРОЦЕССstate: idle in transactionТранзакция открыта долго ⏳BLOCKSОЖИДАЮЩАЯ СЕССИЯ №1Проведение складского документаОЖИДАЮЩАЯ СЕССИЯ №2Обновление товарных регистровДИАГНОСТИЧЕСКИЙ ИТОГ:Процесс запер СУБД без потребления ресурсов CPU.

 

/ 04. СМЕЖНЫЕ МЕТРИКИ

Почему это не обязательно проблема ресурсов сервера

Низкая загрузка CPU сама по себе ничего не доказывает. Но в сочетании с обнаруженными ожиданиями она помогает расставить приоритеты.

Если запросы преимущественно ждут блокировки, увеличение количества процессорных ядер не устранит ожидание. Дополнительные ресурсы не заставят другую транзакцию завершиться.

Проверим основные альтернативные версии.

Гипотеза № 1. Неэффективные SQL-запросы

Не исключено, что часть запросов выполняется медленно из-за неудачного плана выполнения. Но это не объясняет непосредственно обнаруженное ожидание блокировки.

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

Для анализа агрегированной статистики запросов в PostgreSQL часто используют расширение pg_stat_statements, если оно установлено и настроено.

Например:

SELECT
    calls,
    round(total_exec_time::numeric, 1) AS total_ms,
    round(mean_exec_time::numeric, 1) AS mean_ms,
    rows,
    shared_blks_hit,
    shared_blks_read,
    left(query, 500) AS query_text
FROM pg_stat_statements
ORDER BY total_exec_time DESC
LIMIT 20;

* Этот пример подходит для версий PostgreSQL и pg_stat_statements, в которых доступны указанные столбцы.

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

Однако здесь нельзя допускать типичную ошибку: большое total_exec_time не означает, что конкретный запрос является первопричиной текущего инцидента.

Часто вызываемый запрос может закономерно занимать много суммарного времени. Кроме того, статистика агрегирована за период с момента сброса или начала сбора и не всегда позволяет выделить именно проблемный интервал.

Поэтому данные pg_stat_statements нужно сопоставлять с временной шкалой инцидента, а не использовать как готовый рейтинг виновников.

Если после устранения блокировки запрос остаётся медленным, исследуют план выполнения.

Например:

EXPLAIN
SELECT *
FROM production_orders
WHERE order_id = 12345;

* Это условный пример: название таблицы и поля не относятся к какой-либо конкретной системе. Обычный EXPLAIN показывает предполагаемый план, но не выполняет запрос.

Для измерения фактического выполнения используют EXPLAIN ANALYZE, учитывая, что он действительно запускает запрос. На производственной базе это может создать дополнительную нагрузку, а изменяющая команда — привести к реальным изменениям данных. Обычный EXPLAIN показывает предполагаемый план без выполнения команды. Если необходимо измерить фактическое выполнение изменяющего запроса, способ проверки выбирают с учётом транзакционных и внешних побочных эффектов. Обёртывание команды в транзакцию с последующим ROLLBACK отменяет транзакционные изменения, но не гарантирует отсутствия всех побочных эффектов и дополнительной нагрузки.

BEGIN;
EXPLAIN ANALYZE
UPDATE production_orders 
SET status = 'Processing' 
WHERE order_id = 12345;
ROLLBACK;

СУБД выполнит запрос, замерит реальные тайминги и выдаст вам честный план, но после команды ROLLBACK мгновенно вернет данные в исходное состояние. Для таких проверок выбирают безопасные условия и соответствующий способ воспроизведения.

Гипотеза № 2. Исчерпан пул соединений

Ожидание свободного соединения может объяснить, почему пользовательская операция долго не доходит до SQL.

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

Состояние PostgreSQL можно посмотреть так:

SELECT
    application_name,
    state,
    count(*) AS connections,
    max(now() - xact_start) AS oldest_transaction
FROM pg_stat_activity
WHERE datname = current_database()
GROUP BY application_name, state
ORDER BY connections DESC;

Запрос показывает количество соединений в разных состояниях по имени приложения и возраст самой старой транзакции среди соответствующих сессий. Он не показывает напрямую, сколько запросов ждёт внутри пула приложения: такие запросы ещё не обязаны иметь соединение с PostgreSQL.

В нашем примере обнаружена одна транзакция, блокирующая другие операции. Если соединения с заблокированными запросами долго остаются занятыми, пул действительно может начать исчерпываться.

Но это, вероятно, вторичное следствие. Нужно проверить метрики пула и временную последовательность, чтобы установить, когда началось ожидание соединений относительно роста блокировок.

Увеличение пула без устранения блокировки может только позволить большему числу запросов одновременно ждать один и тот же ресурс.

Гипотеза № 3. Не хватает ресурсов сервера или медленно работает диск

Для этой версии проверяют не только загрузку CPU и объём свободной памяти, но и давление на память, дисковые задержки, очереди ввода-вывода, ограничения контейнеров и виртуальной машины.

На уровне PostgreSQL можно дополнительно изучить ожидания процессов и статистику ввода-вывода, доступную в конкретной версии СУБД.

Однако в нашем случае непосредственное ожидание блокировки уже объясняет значительную часть задержки. Это не исключает других проблем, но делает их менее приоритетными для первого этапа.

Гипотеза № 4. Сеть между приложением и базой

Сетевая задержка может увеличивать время обмена и затруднять работу приложения. Но она не объясняет автоматически, почему несколько процессов ждут один и тот же PostgreSQL PID в списке блокирующих процессов.

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

В нашем расследовании пока нет признаков, что сеть является первопричиной. Обнаружена более конкретная зависимость: несколько операций ожидают одну транзакцию.

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

Теперь нужно установить, почему эта транзакция остаётся открытой.

[ DIAGRAM // DIAGNOSTIC_HYPOTHESIS_TREE ]
ТАЙМАУТЫ ПРИ ПРОВЕДЕНИИНЕХВАТКА РЕСУРСОВ / СЕТЬТребует отдельных измеренийПЛОХИЕ ПЛАНЫ SQLВторично: сессии ждут LockIDLE IN TRANSACTIONПОДТВЕРЖДЕНО: pg_blocking_pidsПереход к поиску прикладного контекста

 

/ 05. ВНЕШНЯЯ ЗАВИСИМОСТЬ

Последний SQL не всегда объясняет, чем занята транзакция

В ходе расследования инженер сопоставляет идентификатор блокирующего процесса с журналами приложения.

Выясняется, что перед началом задержек была запущена операция интеграции. Она относится к обработке складского документа и обращается к внешней системе для проверки или подтверждения операции.

В прикладной логике последовательность выглядит так:

  1. Приложение открывает транзакцию в PostgreSQL.
  2. Изменяет данные складского документа и связанные записи.
  3. Обращается к внешней системе.
  4. Ожидает ответ внешней системы.
  5. После ответа завершает транзакцию.

Проблема в том, что внешний вызов выполняется, пока транзакция остаётся открытой.

Пока интеграция ожидает ответа, PostgreSQL не обязательно занят вычислениями. Но изменения, выполненные в транзакции, ещё не зафиксированы, а захваченные блокировки могут продолжать удерживаться.

Другие операции пытаются изменить те же данные и ждут.

Внешний сервис отвечает нестабильно. Обычно он возвращает результат за сотни миллисекунд, но в момент инцидента некоторые обращения занимают десятки секунд.

Таким образом, цепочка выглядит следующим образом:

Задержка внешнего сервиса → длительное ожидание внутри открытой транзакции → удержание блокировок → ожидание проведения других документов → занятые соединения → рост очереди → пользовательские таймауты.

Это уже не просто корреляция нескольких симптомов. Здесь есть конкретный механизм, объясняющий их взаимосвязь.

Обратите внимание: состояние idle in transaction само по себе не доказывает, что приложение ожидает внешний сервис. Для подтверждения необходимо сопоставить время открытой транзакции с журналами приложения или трассировкой внешнего вызова. Сам факт ожидания внешнего ответа обнаруживается при сопоставлении состояния транзакции с журналами приложения или трассировкой.

Если бы инженер смотрел только на загрузку сервера, он мог бы решить, что запас ресурсов достаточен. Если бы анализировал только медленные SQL-запросы, он мог бы начать оптимизировать запросы, которые на самом деле большую часть времени ждут блокировку.

А если бы увеличил таймауты, пользователи просто дольше ждали бы завершения операций.

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

В корпоративных системах разные документы нередко обращаются к одним и тем же данным: остаткам, резервам, состоянию заказа, последовательности проведения или другим объектам, которые должны изменяться согласованно.

Если транзакция удерживает блокировку ресурса, необходимого другим операциям, эти операции не могут продолжить работу до снятия блокировки или другого разрешения конфликта.

Сам PostgreSQL может оставаться полностью работоспособным. Он корректно обеспечивает согласованность данных, не позволяя конкурентным транзакциям нарушить правила доступа.

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

Неисправность находится в организации работы приложения с транзакциями.

Как подтвердить причинную связь

Для подтверждения недостаточно увидеть один долгий idle in transaction. Необходимо собрать несколько согласующихся фактов:

  • ожидающие операции действительно блокируются конкретным процессом;
  • время начала ожидания совпадает с интервалом длительной транзакции;
  • журналы приложения показывают, что внутри этого интервала выполнялся внешний вызов;
  • задержки внешнего вызова совпадают с увеличением времени удержания транзакции;
  • после корректного завершения или снятия блокировки ожидающие операции продолжаются;
  • после изменения прикладной логики длительные блокировки и соответствующие задержки больше не воспроизводятся при сопоставимой нагрузке.

Последний пункт особенно важен. Если блокировку сняли вручную и система ожила, это подтверждает непосредственную роль блокировки, но ещё не доказывает, что причина устранена.

Для этого необходимо исправить логику, которая создаёт длительную транзакцию, и проверить результат. Так расследование переходит от обнаружения аномалии к подтверждению первопричины.

[ DIAGRAM // CASCADE_ROOT_CAUSE_PIPELINE ]
1. ВНЕШНИЙ СЕРВИСНестабильное APIотвечает десятки секунд2. СУБД POSTGRESQLidle in transactionБлокировки удерживаются3. ПОЛЬЗОВАТЕЛИРост очереди, зависаниеКаскадные таймауты ❌

 

/ 06. ОГРАНИЧЕНИЯ РЕБУТА

Что произойдёт, если просто перезапустить приложение

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

Открытая транзакция может завершиться откатом, а блокировки — освободиться. Ожидающие операции получают возможность продолжить работу. Время ответа нормализуется.

Внешне проблема решена.

Но если код по-прежнему выполняет внешний вызов внутри транзакции, следующий медленный ответ внешнего сервиса способен привести к той же ситуации.

Перезапуск устранил текущее состояние, но не механизм его возникновения.

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

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

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

Восстановление и устранение причины — два разных этапа работы. В серьёзном инциденте нужны оба.

[ DIAGRAM // RESTART_VS_ROOT_CAUSE_TIMELINE ]
ВРЕМЯТАЙМАУТЫ / ОЧЕРЕДЬ ЗАПРОСОВПЕРЕЗАПУСК СЛУЖБЫРост блокировокПОВТОРНЫЙ ВСПЛЕСКВнешнее API снова тормозит

 

/ 07. АСИНХРОННЫЙ СЛОЙ

Как устранить причину, а не только освободить блокировку

В нашем случае проблема не решается изменением параметров PostgreSQL. Нужно изменить последовательность действий приложения.

Внешняя система может отвечать медленно, и приложение должно быть готово к этому. Но задержка внешнего сервиса не должна без необходимости превращаться в длительное удержание блокировок в базе данных.

Конкретное решение зависит от бизнес-требований. Нельзя просто вынести любой внешний вызов за пределы транзакции, не проверив, какие гарантии согласованности необходимы операции.

Есть несколько вариантов.

Вариант первый. Сократить транзакцию

Если внешний вызов не требует предварительной фиксации изменений в базе, его можно перенести за пределы транзакции. Тогда транзакция выполняет необходимые изменения и быстро завершается. Внешний вызов производится отдельно, без удержания блокировок, необходимых другим операциям. Однако это решение подходит не всегда. Если результат внешней операции определяет, допустимо ли проведение документа, простое изменение порядка действий может нарушить бизнес-логику. Нельзя сначала окончательно зафиксировать проведение, а затем обнаружить, что внешняя система отказала, если процесс не предусматривает компенсацию такого результата.

Вариант второй. Разделить операцию на состояния

Если взаимодействие с внешней системой обязательно, бизнес-операцию можно организовать как последовательность состояний. Например: документ получает состояние «Ожидает подтверждения»; короткая транзакция сохраняет необходимые данные и задание на интеграцию; фоновый обработчик отправляет запрос во внешнюю систему; после получения результата отдельная короткая транзакция переводит документ в соответствующее конечное состояние. При этом необходимо заранее определить, какие данные разрешено изменять до подтверждения, как система отображает незавершённую операцию и что происходит при отказе интеграции. Это уже изменение модели обработки бизнес-процесса, а не просто техническая оптимизация.

Вариант третий. Использовать transactional outbox

Если требуется надёжно связать изменение данных в PostgreSQL с постановкой задания на интеграцию, одним из распространённых решений является паттерн transactional outbox. В рамках одной транзакции приложение сохраняет бизнес-изменение и запись о необходимости отправить событие. После фиксации отдельный обработчик читает запись outbox и доставляет сообщение внешней системе. Если бизнес-изменение и запись outbox сохраняются в одной транзакции PostgreSQL, они фиксируются атомарно. Поэтому исключается ситуация, когда бизнес-изменение зафиксировано, а запись о необходимости интеграции потеряна из-за сбоя между двумя независимыми действиями. Но outbox не обеспечивает автоматически доставку ровно один раз и не решает все вопросы согласованности. Обработчик должен учитывать повторные попытки, а получатель — поддерживать идемпотентность либо другой механизм защиты от повторного применения операции. Также необходимо определить порядок событий, обработку ошибок и правила повторной отправки. Если бизнес требует немедленного ответа внешней системы, outbox может быть лишь частью решения, а не полной заменой синхронного взаимодействия.

Что изменяем в нашем случае

Для рассматриваемого инцидента выбираем следующую архитектуру:

  • приложение не удерживает блокировки PostgreSQL во время ожидания внешнего сервиса;
  • незавершённая операция имеет явно определённое состояние;
  • задание на интеграцию сохраняется атомарно с необходимыми изменениями данных;
  • повторная доставка события не приводит к повторному проведению документа;
  • ошибки интеграции обрабатываются отдельно от ошибок фиксации транзакции;
  • длительность транзакций и возраст необработанных заданий контролируются мониторингом.

Это не универсальный рецепт для каждой системы. Если операции требуют строгой синхронной согласованности, потребуется другая схема.

Но для данного сценария решение устраняет установленную причину: внешнее ожидание больше не удерживает критические блокировки на протяжении всей операции.

[ DIAGRAM // ISOLATED_TRANSACTION_FIX_FLOW ]
1. ЗАПИСЬ ДОКУМЕНТАСтатус: "Ожидает"Транзакция COMMIT ⚡2. ВНЕШНИЙ ВЫЗОВОжидание ответа APIБАЗА СВОБОДНА 🔓3. ФИНАЛИЗАЦИЯСтатус: "Проведен"Транзакция COMMIT ⚡ИТОГ АРХИТЕКТУРНОГО ИСПРАВЛЕНИЯ:Длительные ожидания вынесены в асинхронный слой, защищая СУБД от каскадных локов.

 

/ 08. ПРОВЕРКА РЕЗУЛЬТАТОВ

Исправление должно подтверждаться измерениями

После изменения кода недостаточно провести один документ и убедиться, что он сохранился.

Необходимо проверить систему в условиях, сопоставимых с теми, при которых возникал инцидент.

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

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

Сравним результаты.

p95 времени проведения документа
До исправления: 28 с
После исправления: 1,1 с
Максимальная длительность критичной транзакции
До исправления: 32 с
После исправления: 0,3 с
Ожидание блокировки в проблемном сценарии
До исправления: До 25 с
После исправления: не наблюдается*
Таймауты проведения
До исправления: Регулярные
После исправления: не воспроизводятся
Зависимость проведения от скорости внешнего ответа
До исправления: Прямая
После исправления: устранена**

* Не наблюдается при тестовой нагрузке.
** Устранена для проверенного сценария.

* Это иллюстративные результаты тестирования, а не реальные показатели проекта. В рабочем отчёте необходимо указывать объём выборки, профиль нагрузки, длительность испытания и условия, при которых получены цифры.

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

Что ещё нужно проверить

  • Корректность бизнес-операции.
    Документ не должен переходить в конечное состояние, если необходимые условия не выполнены. При ошибке внешней системы должна сохраняться предусмотренная бизнесом последовательность восстановления.
  • Повторные попытки.
    После таймаута приложение должно понимать, завершилась ли операция на стороне внешней системы. Слепой повтор может привести к дублированию действия.
  • Очереди.
    Если интеграция замедлилась, количество необработанных заданий может расти, даже когда пользовательские операции больше не блокируются. Поэтому контролируют не только ошибки, но и возраст самого старого задания, скорость поступления и скорость обработки.
  • Длительность транзакций.
    Следует наблюдать за возрастом открытых транзакций, особенно тех, которые удерживают блокировки или мешают обслуживанию базы.
  • Хвост распределения времени ответа.
    Среднее время может улучшиться, хотя небольшая доля операций продолжит задерживаться. Поэтому сравнивают p50, p95 и p99, а также долю ошибок.
  • Пиковая нагрузка.
    Наконец, нужно повторить тест при характерной пиковой нагрузке. Архитектурное изменение, которое работает на пяти пользователях, может вести себя иначе при сотнях одновременных операций.

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

[ DIAGRAM // PERFORMANCE_VERIFICATION_PIPELINE ]
01. ПИКОВЫЙ ТЕСТИскусственная задержкавнешнего API под нагрузкой02. АУДИТ ОЧЕРЕДЕЙПроверка возраста батчейи защита от слепых повторов03. ХВОСТЫ МЕТРИКСравнение p50, p95, p99Исключение скрытых зависаний

 

/ 09. СМЕНА ВЕКТОРОВ

Как продолжать расследование, если причина не подтвердилась

Не каждое расследование заканчивается обнаружением блокировки. В нашем примере мы нашли конкретный механизм, но в другой системе исходные симптомы могут привести к совершенно иной причине.

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

Если запросы активны, но не ждут блокировок

Нужно исследовать их планы выполнения, объём обрабатываемых данных, ожидания ввода-вывода и конкурентную нагрузку. Для PostgreSQL полезны сведения из pg_stat_activity, pg_stat_statements и анализ фактического плана выполнения.

Если запросы к базе быстрые, а пользователи ждут

Необходимо измерить время до получения соединения, время выполнения SQL и время после возврата результата. Если SQL завершается за 100 мс, а операция занимает 10 секунд, оптимизация этого SQL вряд ли устранит основную задержку.

Если серверное время обработки нормально, но клиент получает ответ поздно

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

Если проблема затрагивает только один экземпляр приложения

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

Если одновременно замедлились разные операции и сервисы

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

При этом нельзя ограничиваться поиском одной причины любой ценой. В системе могут одновременно существовать несколько неисправностей. Например, блокировки объясняют задержки проведения документов, а отдельная проблема с сетевым соединением — медленное открытие отчётов.

Хорошая гипотеза объясняет конкретные наблюдения и допускает проверку. Если ожидаемые изменения не произошли, гипотезу пересматривают, а не подгоняют под неё новые факты.

[ DIAGRAM // ALTERNATIVE_DIAGNOSTIC_PATHWAYS ]
ПЕРВИЧНАЯ ГИПОТЕЗА ОТКЛОНЕНАПУТЬ А: СЕССИИ ACTIVEАнализ планов (EXPLAIN)и дискового ввода-выводаПУТЬ Б: БЫСТРЫЙ SQLПоиск накладных расходовв приложении / пуле соединенийПУТЬ В: МАССОВЫЙ СБОЙАудит разделяемых узлов,сети и общей СХД

 

/ 10. РЕГЛАМЕНТ РЕАГИРОВАНИЯ

Порядок действий, который экономит время при реальном инциденте

Когда распределённая система начинает тормозить, расследование можно организовать в семь шагов.

  1. Зафиксировать масштаб и начало проблемы.
    Определить, какие операции замедлились, кого затронула проблема и когда появилось первое отклонение. Сопоставить его с релизами, изменениями конфигурации и фоновой нагрузкой.
  2. Измерить пользовательское время ответа.
    Нужно понимать, насколько ухудшилась работа с точки зрения пользователя, а не только насколько долго выполняется отдельный SQL-запрос. Для критичных операций полезно иметь базовые значения p50 и p95 в нормальном режиме.
  3. Восстановить путь запроса.
    По возможности использовать распределённую трассировку. В системах без неё сопоставить технологические журналы, журналы приложения и СУБД по временным отметкам и идентификаторам операций.
  4. Найти этап, на котором возникает задержка.
    Разделить ожидание соединения, выполнение запроса, блокировки, внешние вызовы и формирование ответа. Не считать время ожидания выполнением полезной работы.
  1. Проверить наиболее вероятную причину.
    Если есть ожидание блокировки — найти блокирующий процесс. Если SQL активно выполняется — изучить план и ресурсы. Если приложение ждёт соединение — проверить пул. Если задерживается сетевой обмен — измерить конкретный маршрут.
  2. Выполнить контролируемое исправление.
    Сначала оценить риски и сохранить диагностические данные. Если требуется срочное восстановление, действовать безопасным способом, не забывая, что временное снятие симптома не равно устранению причины.
  3. Повторить измерения и проверить причинную связь.
    Сравнить показатели до и после изменения в сопоставимых условиях. Проверить не только время ответа, но и связанные очереди, ошибки, ресурсы и корректность бизнес-операций.

Если в результате невозможно объяснить, почему проблема возникла и почему после исправления она исчезла, расследование ещё не завершено.

[ DIAGRAM // SEVEN_STEP_DIAGNOSTIC_PIPELINE ]
ФАКТЫ И МАСШТАБ1. Границы проблемы2. Пользовательский ответ3. Трассировка путиЛОКАЛИЗАЦИЯ И ТЕСТ4. Определение задержки5. Проверка причинИСПРАВЛЕНИЕ И АУДИТ6. Контролируемый фикс7. Измерения и сверка

 

/ 11. НАСТРОЙКА МОНИТОРИНГА И НАБЛЮДАЕМОСТИ

Какие данные нужно собирать заранее

Большая часть времени при диагностике уходит не на выполнение запросов, а на восстановление того, что происходило до сбоя.

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

ДЛЯ ПРИКЛАДНОГО УРОВНЯ:
  • время выполнения критичных операций и распределение времени ответа;
  • количество запросов и доля ошибок;
  • ожидание в очередях и пулах соединений;
  • длительность внешних вызовов;
  • идентификаторы запросов и корреляция событий между компонентами.
ДЛЯ POSTGRESQL:
  • длительность запросов и транзакций;
  • активные сессии и ожидания;
  • блокирующие процессы;
  • ошибки СУБД, включая обнаруженные взаимоблокировки;
  • агрегированная статистика запросов;
  • показатели ввода-вывода и состояние соединений.
ДЛЯ ИНФРАСТРУКТУРЫ:
  • загрузка CPU и давление на память;
  • дисковые задержки и очереди ввода-вывода;
  • сетевые ошибки, задержки и повторные передачи;
  • ограничения контейнеров и виртуальных машин;
  • перезапуски процессов и события исчерпания ресурсов.

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

Отдельно стоит контролировать долгие транзакции. Сам факт открытой транзакции не означает проблему, поэтому полезно учитывать её возраст, состояние соединения, ожидания и наличие блокирующих зависимостей.

Для каждого показателя нужны осмысленные пороги. Порог в 500 мс для одной операции может быть нормальным, а для другой — свидетельствовать о серьёзной деградации. Универсальные значения без учёта требований бизнеса часто создают либо избыток ложных предупреждений, либо опасное молчание мониторинга.

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

Цель наблюдаемости — не сделать систему максимально разговорчивой. Цель — получить достаточно информации, чтобы в критический момент не восстанавливать картину событий по разрозненным сообщениям пользователей.

[ DIAGRAM // THREE_LAYER_OBSERVABILITY_MODEL ]
01ПРИЛОЖЕНИЕ02СУБД03ИНФРАСТРУКТУРАТрассировка & APMТайминг внешних API, пулыPostgreSQL TelemetryЛоки, сессии, pg_statSystem MetricsCPU, RAM, Disk I/O, Network

 

/ 12. РЕЗЮМЕ

Найти компонент недостаточно. Нужно найти механизм отказа.

В начале расследования наша система выглядела исправной. Процессоры не были перегружены, PostgreSQL принимал соединения, а прикладные службы продолжали работать.

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

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

[ RECONSTRUCTED_CAUSAL_CHAIN ]

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

Исправление потребовало изменить порядок взаимодействия с внешней системой и организацию транзакций. После этого результат проверили на сопоставимой нагрузке, включая сценарии замедленного ответа интеграции.

Именно так выглядит полноценная локализация неисправности: от симптома — к конкретному механизму, от механизма — к изменению архитектуры или кода, от изменения — к измеримому подтверждению результата.

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

Он должен последовательно сужать область поиска, пока наблюдения не позволят сформулировать проверяемую гипотезу.

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

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

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

[ DIAGRAM // DIAGNOSTIC_MINDSET_DIVERGENCE ]
ПОИСК ВИНОВНОГО КОМПОНЕНТА«База данных тормозит»Увеличение CPU/RAM без основанийМаскировка симптомовСлепой перезапуск / Увеличение таймаутовАНАЛИЗ МЕХАНИЗМА ОТКАЗАВыявление причинных связейЛокализация: idle in transaction + внешнее APIАрхитектурное решениеВынос вызовов из транзакций (Outbox / Стадии)Сильная диагностика строится на измеримых доказательствах.

 

НАВИГАЦИЯ // SUGGESTED_READING
 
[ Модуль // ИНФРАСТРУКТУРА ]

Мониторинг — это не просто «сервер работает»

 
[ Модуль // ИНФРАСТРУКТУРА ]

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

 
[ Модуль // ИНФРАСТРУКТУРА ]

Как понять, что серверу не хватает ресурсов

 
[ EXPERTISE JOURNAL ]

Все инженерные материалы и экспертные статьи

 
[ CORE GLOSSARY ]

Полный алфавитный справочник ИТ-терминов

AI Ассистент
×
ИИ может ошибаться