Данные были в системе. Магазины их не видели. Никто не получал ошибок, ничего не падало, в логах было чисто. Просто кассир в торговой точке смотрел на старый телефон покупателя, а менеджер в офисе на сервере — на новый. И эта дельта тихо росла каждый день, пока кто-то не позвонил и не сказал: "А вы нам обновлённые карточки клиентов вообще присылаете или нет?".
Если коротко — баг был в том, что код, который записывал объект, не давал платформе зарегистрировать изменение в плане обмена. Обработчик из RabbitMQ писал объект в режиме ОбменДанными.Загрузка = Истина, а в этом режиме авторегистрация не срабатывает. И этого хватило, чтобы вся последняя миля доставки данных перестала работать.
Как устроена синхронизация между сайтом, центром и магазинами
Чтобы стало понятно, что вообще ломалось, нужно описать архитектуру. У клиента — розничная сеть с сайтом. На сайте покупатель регистрируется, заказывает доставку, иногда меняет свой телефон или email в личном кабинете. Сайт — отдельная система, в 1С она не лезет напрямую, обмен идёт через очередь сообщений.
Когда покупатель что-то меняет в профиле, сайт публикует сообщение в RabbitMQ — в очередь import.userout.main.v1. Сообщение содержит идентификатор покупателя и поле, которое изменилось. Дальше в дело вступает 1С.
Центральная база подписана на эту очередь. Регламентное задание раз в минуту вычитывает накопившиеся сообщения, для каждого находит покупателя в справочнике Контрагенты, обновляет нужное поле и записывает объект. Всё штатно. Никаких ошибок, никаких исключений, в логе — успех.
Дальше начинается интересное. Торговые точки работают на локальных базах — у каждого магазина своя копия справочников. Делается это для надёжности: если канал связи с центром лёг, касса всё равно может пробивать чеки и видеть данные клиентов. Локальные базы синхронизируются с центром через классический план обмена.
Механизм плана обмена в 1С работает так. Когда какой-то объект изменяется и это изменение нужно отправить на узлы — платформа "регистрирует" это изменение в служебной таблице. Что-то вроде "вот этот контрагент с такой-то ссылкой изменился, он должен уехать на узлы Магазин-1, Магазин-2, ..., Магазин-12". Следующий цикл обмена забирает зарегистрированные изменения, упаковывает в файл обмена и доставляет на каждый узел.
Вот эта "регистрация изменения на узлах" — самая тонкая часть всей схемы.
Молчаливый сбой
Симптом был такой. Покупатель меняет телефон на сайте. Через минуту сообщение из RabbitMQ обработано — карточка контрагента в центральной базе обновлена, новый номер на месте. Если открыть карточку через клиента 1С, подключенного к серверу — всё видно, всё актуально. Если зайти в локальную базу любого магазина и найти того же покупателя — там старый номер. И никаких ошибок репликации, и никаких пропусков в логе плана обмена. Магазины думают, что они синхронизированы. Центр думает, что данные доставлены. И только сами данные не доехали.
Менеджер заметил случайно. Помогал кассиру оформить возврат, сравнил карточку клиента в кассе с тем, что видел у себя в офисе на сервере. Номер не совпадал. Подумал, что кассир не обновлял базу. Сходил в архивы обмена — последний обмен был сегодня утром, прошёл успешно. Подумал, что баг в конкретной карточке. Проверил вторую — то же самое. Третью — то же. И тут позвонил мне.
Где исчезали изменения
Первая мысль — план обмена. Пошёл смотреть служебную таблицу регистрации изменений по узлу "Магазин-1". Открыл за последний месяц. Изменений по контрагентам — десятки тысяч, всё гладко. Открыл изменения именно по тем покупателям, которые приходят из RabbitMQ. Пусто. Ни одной зарегистрированной правки.
Это уже было подозрительно. Если бы код просто упал и не записал контрагента — записи не было бы и в самом справочнике. А она там есть, в актуальном виде. Значит, код доходит до строки записи, объект сохраняется, но в плане обмена не регистрируется.
Открыл обработчик RabbitMQ-сообщения. Нашёл строку записи:
Контрагент.Телефон = СообщениеИзОчереди.НовыйТелефон;
Контрагент.ОбменДанными.Загрузка = Истина;
Контрагент.Записать();
Чисто и коротко. Выглядит абсолютно правильно. Вызвал в тестовой базе — всё работает, объект сохраняется, при следующем обмене изменение... не уезжает.
И тут я наконец вспомнил особенность платформы, о которой обычно не задумываешься. Если для объекта разрешена авторегистрация, платформа регистрирует изменение сама, и ей всё равно, откуда пришла запись: из формы или из кода. Исключение составляет запись в режиме ОбменДанными.Загрузка = Истина.
Этот режим платформа использует, когда сама применяет данные, пришедшие через обмен: иначе они поехали бы обратно на другие узлы. Разработчик поставил его в обработчике сообщения очереди, чтобы не запускать лишние обработчики событий записи. Оптимизация понятная, но вместе с ними отключилась и авторегистрация.
Ровно эта тонкость и сломала всю схему. Раньше карточки клиентов меняли только операторы через интерфейс 1С, и изменения регистрировались сами. Когда добавили канал из RabbitMQ, никто не подумал, что запись с флагом загрузки ведёт себя иначе. Код стал записывать объекты в обход плана обмена, и магазины перестали получать обновления, но только по тем контрагентам, чьи изменения пришли через очередь.
А самое неприятное в этом — что баг выявить невозможно по логам. Никто не падал. Никто не выбрасывал исключений. Транзакции записи проходили успешно. План обмена доставлял всё, что в нём было зарегистрировано. И если бы менеджер случайно не сравнил два экрана, баг жил бы ещё месяцами, накапливая дельту между центром и магазинами.
Фикс на семь строк
Поправка получилась маленькой. После строки Контрагент.Записать() я добавил явную регистрацию изменения для всех узлов плана обмена, которые на этот объект подписаны:
Контрагент.Телефон = СообщениеИзОчереди.НовыйТелефон;
Контрагент.ОбменДанными.Загрузка = Истина;
Контрагент.Записать();
// Регистрируем изменение во всех узлах плана обмена
ЗапросУзлов = Новый Запрос(
"ВЫБРАТЬ Ссылка ИЗ ПланОбмена.МагазиныРозничнойСети
| ГДЕ НЕ ЭтоУзелЭтойБазы");
Выборка = ЗапросУзлов.Выполнить().Выбрать();
Пока Выборка.Следующий() Цикл
ПланыОбмена.МагазиныРозничнойСети.ЗарегистрироватьИзменения(
Выборка.Ссылка, Контрагент.Ссылка);
КонецЦикла;
Семь строк. Стандартный метод ЗарегистрироватьИзменения делает ровно то, что платформа сделала бы сама без флага загрузки. Просто его нужно вызвать явно.
После этого первый же цикл обмена унёс накопленные изменения по всем затронутым контрагентам. Магазины увидели актуальные телефоны, кассиры перестали смотреть на устаревшие данные, менеджер получил подтверждение и закрыл тикет.
Сам фикс — пять минут работы. Час я потратил на то, чтобы понять почему это работает именно так, и убедиться, что я ничего не упускаю. Час — на тестирование на предсерверной базе и на проверку, что регистрация не вызовет ничего неожиданного (например, лавинной выгрузки тысяч карточек, которая забьёт канал).
Общие наблюдения о распределённых базах в 1С
Этот баг — не уникальный. Я видел его в разных вариациях у разных клиентов. Каждый раз механика похожая: появляется новый канал поступления данных, который раньше не существовал. Программный канал — обработчик очереди, веб-сервис, регламент, внешнее ETL. Он начинает писать в справочник или регистр, всё работает локально, но изменения не уезжают в распределённые узлы.
Мне кажется, корневая проблема даже не в самом API "запись объекта". Корневая проблема в том, что в 1С нет единого места, где система говорит: "Эй, ты записал объект, который участвует в плане обмена — ты уверен, что хочешь, чтобы это изменение никуда не доставлялось?". Платформа молча предполагает, что код знает, что делает. И в большинстве случаев это правда. Но когда новый разработчик пишет обработчик нового канала, он понятия не имеет, что вообще существует план обмена и что от него зависит синхронизация магазинов.
Я для себя сформулировал несколько правил, которые применяю каждый раз, когда вижу программную запись в объект из обработчика какого-нибудь внешнего канала.
Спросить себя: "Этот объект участвует в плане обмена?". Если да — что должно произойти при изменении? Если изменения должны разойтись по узлам, а запись идёт с флагом загрузки, нужна явная регистрация. Если нет — нужно явно понимать почему. Не "автоматически", а осознанно.
Никогда не доверять автоматической регистрации в программном коде. Это ловушка. Код, который полагается на автоматику, выглядит так же, как код, который её не использует. Разница невидима для читающего. Поэтому я всегда вызываю регистрацию явно, даже если она бы и так сработала. Лишний вызов ничего не сломает, отсутствие нужного — сломает молча.
При появлении нового канала записи — пройти по плану обмена. Это уже архитектурное правило. Если в проект добавляется новый ETL, новый веб-сервис, новый обработчик очереди — нужно отдельным шагом проверить: какие справочники и документы он трогает, и какие из них участвуют в плане обмена? Это занимает полчаса, и это полчаса экономят месяцы накопления дельты между узлами.
Что меня беспокоит во всех этих историях
Когда я смотрю на этот баг и на похожие, которые ловлю регулярно, я замечаю общее свойство: разрыв между "данные сохранены" и "данные доставлены". Это два совершенно разных факта, и в распределённой системе очень легко перепутать одно с другим. Код успешно записал объект — это первый факт. План обмена доставил изменение всем узлам — второй. Между ними — служебная таблица регистрации, которая может оказаться пустой, и никто не заметит.
Похожий разрыв я разбирал в статье про интеграции, которые ломаются не там, где ждёшь. Там тоже система работала корректно с точки зрения каждого отдельного этапа, но цепочка из этапов в целом не давала ожидаемого результата. Каждое звено живо, цепочка — мертва.
Чем больше каналов поступления данных в систему, тем больше мест, в которых эта последняя миля может потеряться. Каждый новый канал — это потенциально новое место, где "данные сохранены" и "данные доставлены" могут разойтись. И эти баги почти всегда тихие. Никаких ошибок, никаких алертов. Просто вместо одного источника правды — два, которые расходятся со временем. Точно так же, как в разборе кеширования отчётов и рассылки: пока никто не сравнивает два числа, мир выглядит согласованным.
В этом проекте всё закончилось семью строками кода и одним телефоном клиента, который наконец-то стал виден кассиру торговой точки. Но я знаю, что баг этого класса в 1С-системах появляется заново каждый раз, когда добавляется новый канал записи. Поэтому я даже не удивлюсь, если через полгода кто-то добавит ETL из CRM в эту же базу, не вспомнит про план обмена, и магазины снова начнут отставать. Это не вопрос "если". Это вопрос "когда".
Распределённые системы прощают многое. Но они не прощают молчаливых разрывов между "я записал" и "оно дошло".





