Содержание
- Что такое Active metadata
- Пассивные и активные метаданные
- Архитектура слоя активных метаданных
- Как работают активные метаданные
- Событие изменения метаданных
- Конвейер действий
- Ограничения и подводные камни
- Когда применять, а когда нет
- Практика, активные метаданные на событиях PostgreSQL
- Источник событий на event trigger и pg_notify
- Что видит обход по расписанию и что видит слушатель
- Правила, распространение тега PII и анализ влияния
- Заключение
- Референсные ссылки
Active metadata (активные метаданные) это подход к управлению метаданными, при котором изменение метаданных само порождает событие, а правило реагирует на него действием в соседних системах. Тег ставится, доступ отзывается, владелец дашборда получает алерт, и для этого никому не нужно открывать каталог данных. Пассивный каталог отвечает на вопрос «что у нас есть», а активный слой ещё и действует, когда это «что есть» меняется.
В практической части цикл «событие, правило, действие» собран на PostgreSQL 18.6 без каталога и без Kafka, и каждая цифра в тексте взята из реального прогона.
Что такое Active metadata
Метаданные это данные о данных, а именно схемы таблиц, владельцы, теги, data lineage (происхождение данных) и статистика использования. Классический каталог данных (data catalog) собирает их и показывает человеку, который пришёл с вопросом. Термин active metadata продвигает Gartner, аналитическая компания, которая ведёт обзоры рынков корпоративного ПО. По пересказу Alation, вендора каталогов данных, в 2021 году Gartner заменил отчёт Magic Quadrant for Metadata Management Solutions на Market Guide for Active Metadata Management. Сам отчёт платный, поэтому определение здесь передаётся по вторичным источникам, а не цитатой.
Суть, на которой сходятся источники, проще любой формулировки. Метаданные перестают быть справочником и становятся потоком событий, а каталог узнаёт об изменении в момент изменения и может ответить на него сам. Справочник при этом остаётся, активный слой надстраивается над тем же графом метаданных (metadata graph) и пишет результаты действий обратно в него.
Пассивные и активные метаданные
Разница видна на любом атрибуте каталога, если спросить, кто и когда его обновляет. Подробно о самом управлении метаданными и о делении на active и passive рассказывает статья блога Metadata Management. Данные о данных как ключ к их ценности, а здесь отличия сведены в таблицу.
| Признак | Пассивные метаданные | Активные метаданные |
|---|---|---|
| Кто инициирует обновление | Краулер каталога по расписанию или человек | Событие в источнике или в самом каталоге |
| Когда обновляются | При следующем обходе, раз в час или раз в сутки | В момент изменения, с задержкой доставки события |
| Где живут | В каталоге, читаются через интерфейс и поиск | В графе метаданных, плюс шина событий и движок правил |
| Изменение схемы между обходами | Видно только итоговое состояние, промежуточные теряются | Каждая команда приходит отдельным событием |
| Кто действует | Человек, который открыл каталог | Правило, которое ставит тег, меняет права, пишет в мессенджер или запускает задачу |
| Типовая реализация | Каталог с загрузкой метаданных по расписанию | DataHub Actions, слушатель событий каталога или базы |
Строка про промежуточные состояния не теоретическая, в практике ниже пассивный каталог пропустил колонку, которую добавили и удалили между обходами.
Архитектура слоя активных метаданных
Слой активных метаданных собирается из пяти частей, и у каждой есть готовые реализации в каталогах с открытым исходным кодом:
- Сбор. Метаданные попадают в граф двумя путями. Pull-краулер обходит источники по расписанию, push-интеграция присылает событие сама, например из оркестратора или из базы данных.
- Граф метаданных. Хранилище сущностей и связей между ними, то есть таблиц, колонок, дашбордов, владельцев, тегов и рёбер lineage.
- Шина событий (event bus). Каждое изменение графа публикуется как событие, обычно в Apache Kafka. Подписчиков может быть сколько угодно, и друг другу они не мешают.
- Движок правил и действий. Читает события, отбирает нужные и выполняет действие по правилу вида «появилась колонка с персональными данными, поставь тег и закрой доступ».
- Обратная интеграция. Действие уходит во внешнюю систему, в мессенджер, оркестратор или систему прав доступа, а его результат записывается обратно в граф.
Последний пункт замыкает цикл, и именно он отличает активный слой от рассылки уведомлений об изменениях.
Архитектура Данных
Код курса
ARMG
Ближайшая дата курса
21 декабря, 2026
Продолжительность
24 ак.часов
Стоимость обучения
76 800
Как работают активные метаданные
Механику удобно разобрать на DataHub, каталоге метаданных с открытым исходным кодом, где событийный слой вынесен в отдельный фреймворк DataHub Actions и описан в документации.
Событие изменения метаданных
DataHub Actions поддерживает два типа событий, EntityChangeEvent_v1 и MetadataChangeLog_v1 (MCL, Metadata Change Log). Событие первого типа, по документации, порождается, когда у сущности DataHub, например у датасета, дашборда или графика, меняется что-то из заранее перечисленного. В каталоге таких событий есть добавленный тег с категорией TAG и операцией ADD, новое поле схемы с категорией TECHNICAL_SCHEMA, смена владельца, домена или термина глоссария. Общие поля entityUrn, category, operation и auditStamp говорят правилу, что изменилось, как и кем. События приходят из источника, по умолчанию это Kafka Event Source, а в облачной версии DataHub Cloud Event Source.
Конвейер действий
Обработчик описывается YAML-конфигом pipeline. Обязательны в нём имя, источник событий и одно действие (action), а фильтры (filters) и трансформеры (transformers) необязательны. Фильтры проверяются по порядку и объединяются через AND, трансформеры выполняются последовательно и меняют событие перед действием. Запускается конвейер командой datahub actions -c с путём к конфигу, и конфигов можно передать несколько. Полный список параметров приведён в документации DataHub Actions Framework.
Отдельного внимания заслуживают сбои. Документация заявляет доставку at-least-once (хотя бы один раз), и источник подтверждает событие только после того, как оно дошло до действия, поэтому одно и то же событие может прийти повторно, а действие должно быть идемпотентным. Параметр retry_count по умолчанию равен 0, так что упавшее действие на том же событии не повторяется. Параметр failure_mode со значением CONTINUE пропускает событие и идёт дальше, со значением THROW останавливает конвейер, и в обоих случаях событие записывается в файл failed_events.log в каталоге failed_events_dir.
Ограничения и подводные камни
Активный слой это распределённая система поверх каталога, и проблемы у него соответствующие:
- Доставка и повторы. Событие может потеряться или прийти дважды, и правило должно пережить оба случая. В демо отключённый слушатель пропущенное нашёл только в журнале событий.
- Окно до действия. Действие асинхронное и изменение не блокирует, в демо представление с персональными данными десятки миллисекунд было открыто аналитику. Для чувствительных данных активный слой дополняет запрет по умолчанию, а не заменяет его.
- Петли. Действие меняет метаданные и порождает новое событие, на которое без фильтра по отправителю правило среагирует снова.
- Точность lineage. Правило распространения работает ровно настолько, насколько точен граф. Lineage на уровне таблиц пометит представление целиком, даже если чувствительна одна колонка из пяти.
- Шум. Алерт на каждое изменение схемы быстро приучает команду не читать канал. Правило лучше вешать на последствие, например на сломанного потребителя, а не на сам факт изменения.
- Стоимость правил. Каждое правило это код, который тестируют и сопровождают, как любой код конвейера данных.
Таким образом, активные метаданные переносят часть ручной работы в автоматику, но приносят с собой гарантии доставки, порядок событий и отладку асинхронных цепочек.
Когда применять, а когда нет
Активный слой окупается там, где изменений много, а реакция на них повторяется. Типовые сценарии выглядят так:
- Персональные данные и права. Новая колонка с подходящим именем или классом получает тег PII (Personally Identifiable Information, персональные данные), тег идёт по lineage, доступ закрывается правилом.
- Анализ влияния (impact analysis). Удаление или переименование колонки сразу даёт список сломанных отчётов и их владельцев.
- Качество и свежесть. Упавшая проверка качества помечает датасет, и зависимые задачи оркестратора не стартуют на плохих данных.
- Аудит изменений. Журнал событий отвечает на вопрос, кто и когда поменял схему.
Не нужен такой слой небольшой команде с десятком таблиц, где схема меняется раз в месяц, и там, где нет lineage хотя бы на уровне таблиц, потому что без графа правилам негде распространять теги и считать влияние. Начинать в любом случае стоит с управления данными как процесса, и роль каталога в нём разобрана в статье Data Governance. Как построить систему руководства и контроля данными, которая работает. Архитектуру платформы, в которую встраивается такой слой, вместе с Data Governance и DAMA DMBOK разбирает курс «Архитектура Данных».
Практическая архитектура данных
Код курса
PRAR
Ближайшая дата курса
30 ноября, 2026
Продолжительность
24 ак.часов
Стоимость обучения
76 800
Практика, активные метаданные на событиях PostgreSQL
По традиции весь код используемый в статье выкладываем на наш GitHub репозиторий
Демо собирает весь цикл внутри одной базы PostgreSQL 18.6. Event trigger (событийный триггер) играет роль сбора, служебная схема meta служит графом метаданных, pg_notify заменяет шину, а слушатель на Python с psycopg 3.3.8 выполняет правила. Kafka и каталог не нужны, поэтому механизм виден целиком. Прогон сделан на Ubuntu 24.04.4 с Docker 29.1.3 и Python 3.12.3, контейнер с базой занял 30 МиБ памяти.
Источник событий на event trigger и pg_notify
Event trigger в PostgreSQL срабатывает не на изменение строк, а на команду DDL (Data Definition Language, язык определения данных). Функция pg_event_trigger_ddl_commands() доступна только в триггере на событие ddl_command_end и возвращает объекты, затронутые командой. Функция pg_event_trigger_dropped_objects() работает в триггере на sql_drop и перечисляет удалённое, включая снесённое каскадом. Файл setup.sql создаёт схемы демо, роль analyst, таблицы графа в схеме meta и оба триггера.
Событие пишется строкой в таблицу meta.events, а через pg_notify уходит только его id. Причин две. Payload уведомления в конфигурации по умолчанию должен быть короче 8000 байт, а отключённый слушатель уведомление не получает вовсе, что подтвердил прогон, и строка в таблице решает обе проблемы.
-- PostgreSQL 18.6, прогнано на стенде 2026-11-13: источник событий метаданных на event trigger и pg_notify
-- Выполняется один раз при первом старте контейнера на чистом томе (docker-entrypoint-initdb.d).
-- Данные демо: сырой слой и два слоя производных представлений
CREATE SCHEMA raw;
CREATE SCHEMA mart;
CREATE SCHEMA report;
CREATE TABLE raw.customers (
id int PRIMARY KEY,
name text NOT NULL,
city text
);
-- Роль аналитика: читает всё, что появляется в mart и report (права по умолчанию)
CREATE ROLE analyst NOLOGIN;
GRANT USAGE ON SCHEMA mart, report TO analyst;
ALTER DEFAULT PRIVILEGES IN SCHEMA mart, report GRANT SELECT ON TABLES TO analyst;
-- Служебная схема meta: это и есть граф метаданных, который обновляют события
CREATE SCHEMA meta;
-- Журнал событий. pg_notify несёт только id строки: payload ограничен 8000 байт,
-- а строка в таблице переживает отсутствие слушателя
CREATE TABLE meta.events (
id bigserial PRIMARY KEY,
at timestamptz NOT NULL DEFAULT clock_timestamp(),
txid xid8 NOT NULL DEFAULT pg_current_xact_id(),
event text NOT NULL, -- ddl_command_end или sql_drop
tag text NOT NULL, -- ALTER TABLE, CREATE VIEW, REVOKE ...
app text NOT NULL, -- application_name сессии, которая сделала изменение
objects jsonb NOT NULL, -- затронутые объекты
query text -- текст команды, обрезанный
);
-- Колонки, которые каталог знает на текущий момент
CREATE TABLE meta.columns (
relation text NOT NULL,
column_name text NOT NULL,
PRIMARY KEY (relation, column_name)
);
-- Lineage: колонка-источник -> представление, представление -> внешний потребитель
CREATE TABLE meta.lineage (
upstream text NOT NULL,
downstream text NOT NULL,
kind text NOT NULL, -- view или consumer
PRIMARY KEY (upstream, downstream)
);
-- Внешние потребители регистрируются в каталоге руками: базе про дашборды ничего не известно
INSERT INTO meta.lineage VALUES
('mart.customers_by_city', 'bi.city_dashboard', 'consumer'),
('report.newsletter', 'crm.mailing_job', 'consumer');
CREATE TABLE meta.tags (
asset text NOT NULL,
tag text NOT NULL,
source text NOT NULL, -- какое правило или какой предок поставил тег
at timestamptz NOT NULL DEFAULT clock_timestamp(),
PRIMARY KEY (asset, tag)
);
CREATE TABLE meta.actions (
id bigserial PRIMARY KEY,
at timestamptz NOT NULL DEFAULT clock_timestamp(),
event bigint, -- id события, на которое среагировало правило
rule text NOT NULL,
asset text NOT NULL,
action text NOT NULL
);
-- Какие колонки читает представление: по зависимостям его правила перезаписи в pg_depend
CREATE FUNCTION meta.view_reads(v oid) RETURNS jsonb
LANGUAGE sql STABLE AS $$
SELECT coalesce(jsonb_agg(DISTINCT n.nspname || '.' || c.relname || '.' || a.attname), '[]'::jsonb)
FROM pg_rewrite rw
JOIN pg_depend d ON d.classid = 'pg_rewrite'::regclass AND d.objid = rw.oid
AND d.refclassid = 'pg_class'::regclass AND d.refobjsubid > 0
JOIN pg_class c ON c.oid = d.refobjid
JOIN pg_namespace n ON n.oid = c.relnamespace
JOIN pg_attribute a ON a.attrelid = d.refobjid AND a.attnum = d.refobjsubid
WHERE rw.ev_class = v AND d.refobjid <> v
$$;
-- Конец любой DDL-команды: собрать затронутые объекты, записать событие, отправить его id
CREATE FUNCTION meta.on_ddl_end() RETURNS event_trigger
LANGUAGE plpgsql AS $$
DECLARE
r record;
objs jsonb := '[]'::jsonb;
eid bigint;
BEGIN
FOR r IN SELECT * FROM pg_event_trigger_ddl_commands() LOOP
-- изменения самой схемы meta событиями не считаем
IF r.schema_name = 'meta' OR r.in_extension THEN
CONTINUE;
END IF;
objs := objs || jsonb_build_object(
'type', r.object_type,
'identity', r.object_identity,
-- состав колонок на момент события, чтобы слушатель мог сравнить с тем, что знал раньше
'columns', CASE WHEN r.object_type IN ('table', 'view') THEN
(SELECT jsonb_agg(attname::text ORDER BY attnum)
FROM pg_attribute
WHERE attrelid = r.objid AND attnum > 0 AND NOT attisdropped)
END,
'reads', CASE WHEN r.object_type = 'view' THEN meta.view_reads(r.objid) END);
END LOOP;
IF jsonb_array_length(objs) = 0 THEN
RETURN;
END IF;
INSERT INTO meta.events (event, tag, app, objects, query)
VALUES (tg_event, tg_tag, current_setting('application_name'), objs, left(current_query(), 300))
RETURNING id INTO eid;
-- уведомление уйдёт слушателям только после коммита транзакции с DDL
PERFORM pg_notify('meta_events', eid::text);
END
$$;
-- Удаление объектов: колонки, таблицы, представления, в том числе снесённые каскадом
CREATE FUNCTION meta.on_sql_drop() RETURNS event_trigger
LANGUAGE plpgsql AS $$
DECLARE
r record;
objs jsonb := '[]'::jsonb;
eid bigint;
BEGIN
FOR r IN SELECT * FROM pg_event_trigger_dropped_objects() LOOP
IF r.schema_name = 'meta'
OR r.object_type NOT IN ('table', 'view', 'materialized view', 'table column') THEN
CONTINUE;
END IF;
objs := objs || jsonb_build_object(
'type', r.object_type,
'identity', r.object_identity,
'original', r.original); -- false: объект снесён каскадом, а не назван в команде
END LOOP;
IF jsonb_array_length(objs) = 0 THEN
RETURN;
END IF;
INSERT INTO meta.events (event, tag, app, objects, query)
VALUES (tg_event, tg_tag, current_setting('application_name'), objs, left(current_query(), 300))
RETURNING id INTO eid;
PERFORM pg_notify('meta_events', eid::text);
END
$$;
CREATE EVENT TRIGGER meta_ddl_end ON ddl_command_end EXECUTE FUNCTION meta.on_ddl_end();
CREATE EVENT TRIGGER meta_sql_drop ON sql_drop EXECUTE FUNCTION meta.on_sql_drop();
Файл docker-compose.yml поднимает postgres:18.6 и выполняет setup.sql при первом старте на чистом томе. Единственная зависимость Python лежит в requirements.txt, это psycopg[binary] версии 3.3.8.
# postgres 18.6 в Docker, прогнано на стенде 2026-11-13: источник событий метаданных на event trigger и pg_notify
services:
pg:
image: postgres:18.6
container_name: active-metadata-pg
mem_limit: 1g
environment:
POSTGRES_USER: demo
POSTGRES_PASSWORD: demo
POSTGRES_DB: demo
ports:
- "127.0.0.1:55441:5432"
volumes:
- pgdata:/var/lib/postgresql
# схемы демо, служебная схема meta и event trigger создаются при первом старте на чистом томе
- ./setup.sql:/docker-entrypoint-initdb.d/01_setup.sql:ro
healthcheck:
# -h 127.0.0.1: на время initdb временный сервер слушает только сокет, по TCP готов уже рабочий
test: ["CMD-SHELL", "pg_isready -h 127.0.0.1 -U demo -d demo"]
interval: 2s
timeout: 3s
retries: 30
volumes:
pgdata:
# Docker 29.1.3, Docker Compose 2.40.3, PostgreSQL 18.6, Python 3.12.3; команды из RUNBOOK.md, проверены на стенде 2026-11-13 cd /path/to/active_metadata python3 -m venv .venv .venv/bin/pip install -r requirements.txt docker compose up -d --wait docker compose exec -T pg psql -U demo -d demo -XAtc \ "SELECT evtname || ' ' || evtevent || ' ' || evtfoid::regproc FROM pg_event_trigger ORDER BY 1" .venv/bin/python passive_vs_active.py .venv/bin/python active_actions.py docker compose down -v
# фрагмент run_output.txt: старт стенда, PostgreSQL 18.6, прогон на стенде 2026-11-13 19:47 UTC Container active-metadata-pg Healthy PostgreSQL 18.6 (Debian 18.6-1.pgdg13+2) on x86_64-pc-linux-gnu, compiled by gcc (Debian 14.2.0-19) 14.2.0, 64-bit meta_ddl_end ddl_command_end meta.on_ddl_end meta_sql_drop sql_drop meta.on_sql_drop
Что видит обход по расписанию и что видит слушатель
Скрипт passive_vs_active.py дважды обходит information_schema как пассивный каталог, а между обходами миграция добавляет колонку promo_code, записывает в неё значение, удаляет её и добавляет phone. Затем тот же скрипт проверяет откат транзакции и отключённого слушателя.
# psycopg 3.3.8, PostgreSQL 18.6, прогнано на стенде 2026-11-13
"""Пассивный каталог против событий: что видит обход по расписанию и что видит слушатель.
1. Каталог снимает состав колонок дважды, между снимками колонку добавили и удалили.
2. Слушатель LISTEN получает каждое изменение отдельным событием.
3. Откаченная транзакция события не порождает.
4. Слушатель, который был отключён, уведомлений не получает, догоняет по журналу meta.events.
"""
import os
import time
import psycopg
DSN = os.environ.get("META_DSN", "host=127.0.0.1 port=55441 user=demo password=demo dbname=demo")
CHANNEL = "meta_events"
def connect(app: str) -> psycopg.Connection:
# application_name попадает в событие: по нему видно, кто сделал изменение
return psycopg.connect(DSN, autocommit=True, application_name=app)
def reset(conn: psycopg.Connection) -> None:
"""Исходное состояние: таблица из трёх колонок без представлений, пустой журнал. Слушателей пока нет."""
conn.execute("DROP TABLE IF EXISTS raw.customers CASCADE")
conn.execute("CREATE TABLE raw.customers (id int PRIMARY KEY, name text NOT NULL, city text)")
conn.execute(
"INSERT INTO raw.customers VALUES (1, 'Анна', 'Москва'), (2, 'Борис', 'Казань'), (3, 'Вера', 'Москва')"
)
conn.execute("TRUNCATE meta.events, meta.columns, meta.tags, meta.actions RESTART IDENTITY")
conn.execute("DELETE FROM meta.lineage WHERE kind <> 'consumer'")
def crawl(conn: psycopg.Connection) -> set[str]:
"""Пассивный сбор: каталог сам ходит в information_schema и снимает текущее состояние."""
rows = conn.execute(
"SELECT table_schema || '.' || table_name || '.' || column_name "
"FROM information_schema.columns WHERE table_schema = 'raw'"
).fetchall()
return {r[0] for r in rows}
def drain(listener: psycopg.Connection, reader: psycopg.Connection, timeout: float = 1.0) -> list[tuple]:
"""Забрать уведомления, пришедшие за timeout секунд, и прочитать события из журнала по id."""
ids = [int(n.payload) for n in listener.notifies(timeout=timeout)]
if not ids:
return []
return reader.execute(
"SELECT id, event, tag, app, objects FROM meta.events WHERE id = ANY(%s) ORDER BY id", (ids,)
).fetchall()
def show(events: list[tuple]) -> None:
for eid, event, tag, app, objects in events:
parts = []
for o in objects:
text = f"{o['type']} {o['identity']}"
if o.get("columns"):
text += f" колонки={o['columns']}"
parts.append(text)
print(f" #{eid} {event:<15} {tag:<12} app={app:<14} {'; '.join(parts)}")
def main() -> None:
admin = connect("demo_reset")
reset(admin)
print("=== 1. Пассивный каталог: два обхода по расписанию ===")
crawler = connect("catalog_crawler")
snap1 = crawl(crawler)
print("обход 1:", sorted(snap1))
listener = connect("catalog_listener")
listener.execute(f"LISTEN {CHANNEL}")
# Между обходами миграция добавляет временную колонку, удаляет её и добавляет постоянную
migration = connect("etl_migration")
for sql in (
"ALTER TABLE raw.customers ADD COLUMN promo_code text",
"UPDATE raw.customers SET promo_code = 'WELCOME10' WHERE id = 1",
"ALTER TABLE raw.customers DROP COLUMN promo_code",
"ALTER TABLE raw.customers ADD COLUMN phone text",
):
migration.execute(sql)
print(" миграция:", sql)
snap2 = crawl(crawler)
print("обход 2:", sorted(snap2))
print("пассивный каталог видит: добавлено", sorted(snap2 - snap1), "удалено", sorted(snap1 - snap2))
print()
print("=== 2. Активный слой: те же изменения как события ===")
reader = connect("catalog_reader")
events = drain(listener, reader)
show(events)
print(f"событий получено: {len(events)}; UPDATE события не дал: это DML, а не DDL")
print()
print("=== 3. Откат: DDL внутри транзакции, которая не закоммитилась ===")
try:
with migration.transaction():
migration.execute("ALTER TABLE raw.customers ADD COLUMN tmp_flag boolean")
raise psycopg.Rollback()
except psycopg.Rollback:
pass
events = drain(listener, reader)
rows = reader.execute("SELECT count(*) FROM meta.events WHERE query LIKE '%tmp_flag%'").fetchone()[0]
print(f"уведомлений после ROLLBACK: {len(events)}; строк в журнале про tmp_flag: {rows}")
print()
print("=== 4. Слушатель был отключён ===")
last_seen = reader.execute("SELECT max(id) FROM meta.events").fetchone()[0]
listener.close()
migration.execute("ALTER TABLE raw.customers ADD COLUMN birth_date date")
print(" миграция при отключённом слушателе: ALTER TABLE raw.customers ADD COLUMN birth_date date")
listener = connect("catalog_listener")
listener.execute(f"LISTEN {CHANNEL}")
t0 = time.monotonic()
events = drain(listener, reader, timeout=2.0)
print(f"уведомлений после переподключения за {time.monotonic() - t0:.1f} с: {len(events)}")
missed = reader.execute(
"SELECT id, event, tag, app, objects FROM meta.events WHERE id > %s ORDER BY id", (last_seen,)
).fetchall()
print(f"догоняем по журналу meta.events с id > {last_seen}: {len(missed)}")
show(missed)
for c in (admin, crawler, listener, migration, reader):
c.close()
if __name__ == "__main__":
main()
# фрагмент run_output.txt: passive_vs_active.py, PostgreSQL 18.6 и psycopg 3.3.8, прогон на стенде 2026-11-13 19:47 UTC === 1. Пассивный каталог: два обхода по расписанию === обход 1: ['raw.customers.city', 'raw.customers.id', 'raw.customers.name'] миграция: ALTER TABLE raw.customers ADD COLUMN promo_code text миграция: UPDATE raw.customers SET promo_code = 'WELCOME10' WHERE id = 1 миграция: ALTER TABLE raw.customers DROP COLUMN promo_code миграция: ALTER TABLE raw.customers ADD COLUMN phone text обход 2: ['raw.customers.city', 'raw.customers.id', 'raw.customers.name', 'raw.customers.phone'] пассивный каталог видит: добавлено ['raw.customers.phone'] удалено [] === 2. Активный слой: те же изменения как события === #1 ddl_command_end ALTER TABLE app=etl_migration table raw.customers колонки=['id', 'name', 'city', 'promo_code'] #2 sql_drop ALTER TABLE app=etl_migration table column raw.customers.promo_code #3 ddl_command_end ALTER TABLE app=etl_migration table raw.customers колонки=['id', 'name', 'city'] #4 ddl_command_end ALTER TABLE app=etl_migration table raw.customers колонки=['id', 'name', 'city', 'phone'] событий получено: 4; UPDATE события не дал: это DML, а не DDL === 3. Откат: DDL внутри транзакции, которая не закоммитилась === уведомлений после ROLLBACK: 0; строк в журнале про tmp_flag: 0 === 4. Слушатель был отключён === миграция при отключённом слушателе: ALTER TABLE raw.customers ADD COLUMN birth_date date уведомлений после переподключения за 2.0 с: 0 догоняем по журналу meta.events с id > 4: 1 #6 ddl_command_end ALTER TABLE app=etl_migration table raw.customers колонки=['id', 'name', 'city', 'phone', 'birth_date'] --- passive_vs_active.py шёл 5 с, rc=0
Пассивный каталог увидел только phone. Колонка promo_code прожила между обходами и исчезла бесследно, хотя в неё успели записать значение. Слушатель получил четыре события, по одному на каждую DDL-команду, а UPDATE события не дал, потому что это DML. Заметна и особенность PostgreSQL. Событие ddl_command_end по ALTER TABLE называет таблицу, но не колонку, и какую колонку добавили, слушатель узнаёт только сравнением состава колонок, тогда как sql_drop называет удалённую колонку точно.
Откаченная транзакция не оставила ни уведомления, ни строки в журнале, потому что NOTIFY уходит только после коммита. Слушатель после переподключения за 2 секунды не получил ничего, и событие #6 нашлось только в журнале. Номер 5 пропал вместе с откаченной транзакцией, потому что sequence не откатывается, и догон по условию «id больше последнего виденного» здесь корректен лишь потому, что писатель один. При нескольких параллельных писателях меньший id может закоммититься позже большего, и такой догон его пропустит.
Правила, распространение тега PII и анализ влияния
Скрипт active_actions.py держит три правила. Правило pii_by_name ставит тег pii на новую колонку, если её имя совпало с шаблоном. Правило pii_propagation срабатывает на создание представления, берёт из события список прочитанных колонок, который функция meta.view_reads() достала из pg_depend, и при наличии помеченной колонки ставит тег на представление и отзывает SELECT у роли analyst. Правило impact_on_drop на удаление обходит lineage вниз до внешних потребителей и шлёт алерт владельцу. Сам слушатель подключается с application_name active_metadata и события с этим именем отбрасывает.
# psycopg 3.3.8, PostgreSQL 18.6, прогнано на стенде 2026-11-13
"""Активные метаданные на событиях PostgreSQL: событие -> фильтр -> правило -> действие.
Слушатель получает id события через LISTEN, читает событие из meta.events и применяет правила:
pii_by_name новая колонка с именем email, phone, passport, birth_date получает тег pii;
pii_propagation представление, которое читает колонку с тегом pii, получает тег и теряет
SELECT у роли analyst (тег идёт по lineage дальше, представление над представлением);
impact_on_drop удаление колонки или представления: по lineage находим внешних потребителей и шлём алерт.
События, которые породил сам слушатель (его REVOKE тоже DDL), отсекаются фильтром, иначе возникает петля.
"""
import os
import re
import time
import psycopg
DSN = os.environ.get("META_DSN", "host=127.0.0.1 port=55441 user=demo password=demo dbname=demo")
CHANNEL = "meta_events"
SELF_APP = "active_metadata"
PII_RE = re.compile(r"(email|phone|passport|birth_date)")
stats = {"events": 0, "self": 0, "actions": 0}
def connect(app: str) -> psycopg.Connection:
return psycopg.connect(DSN, autocommit=True, application_name=app)
def reset(conn: psycopg.Connection) -> None:
"""Исходное состояние: таблица без представлений, пустой граф, только внешние потребители."""
conn.execute("DROP TABLE IF EXISTS raw.customers CASCADE")
conn.execute("CREATE TABLE raw.customers (id int PRIMARY KEY, name text NOT NULL, city text)")
conn.execute(
"INSERT INTO raw.customers VALUES (1, 'Анна', 'Москва'), (2, 'Борис', 'Казань'), (3, 'Вера', 'Москва')"
)
conn.execute("TRUNCATE meta.events, meta.columns, meta.tags, meta.actions RESTART IDENTITY")
conn.execute("DELETE FROM meta.lineage WHERE kind <> 'consumer'")
def bootstrap(cat: psycopg.Connection) -> None:
"""Первичный обход: события несут только изменения, базовое состояние каталог снимает сам."""
cat.execute(
"INSERT INTO meta.columns SELECT table_schema || '.' || table_name, column_name "
"FROM information_schema.columns WHERE table_schema IN ('raw', 'mart', 'report')"
)
# ── действия ──────────────────────────────────────────────────────────────
def act(cat: psycopg.Connection, eid: int, rule: str, asset: str, action: str) -> None:
cat.execute("INSERT INTO meta.actions (event, rule, asset, action) VALUES (%s, %s, %s, %s)",
(eid, rule, asset, action))
stats["actions"] += 1
print(f" -> [{rule}] {asset}: {action}")
def tag(cat: psycopg.Connection, eid: int, rule: str, asset: str, source: str) -> None:
cur = cat.execute(
"INSERT INTO meta.tags (asset, tag, source) VALUES (%s, 'pii', %s) ON CONFLICT DO NOTHING", (asset, source)
)
if cur.rowcount:
act(cat, eid, rule, asset, f"тег pii ({source})")
def is_pii(cat: psycopg.Connection, column: str) -> bool:
"""Колонка считается pii, если тег стоит на ней самой или на всём представлении, которому она принадлежит."""
relation = column.rsplit(".", 1)[0]
return cat.execute(
"SELECT EXISTS (SELECT 1 FROM meta.tags WHERE tag = 'pii' AND asset IN (%s, %s))", (column, relation)
).fetchone()[0]
# ── правила ───────────────────────────────────────────────────────────────
def on_table_changed(cat: psycopg.Connection, eid: int, obj: dict) -> None:
"""Событие говорит «ALTER TABLE raw.customers», какая колонка, видно только сравнением составов."""
rel = obj["identity"]
before = {r[0] for r in cat.execute("SELECT column_name FROM meta.columns WHERE relation = %s", (rel,))}
after = set(obj["columns"] or [])
added, removed = sorted(after - before), sorted(before - after)
print(f" сравнение с каталогом: добавлены {added}, удалены {removed}")
cat.execute("DELETE FROM meta.columns WHERE relation = %s", (rel,))
cat.cursor().executemany("INSERT INTO meta.columns VALUES (%s, %s)", [(rel, c) for c in sorted(after)])
for col in added:
if PII_RE.search(col):
tag(cat, eid, "pii_by_name", f"{rel}.{col}", f"имя колонки совпало с {PII_RE.pattern}")
def on_view_created(cat: psycopg.Connection, eid: int, obj: dict) -> None:
view, reads = obj["identity"], obj["reads"] or []
print(f" lineage: {view} читает {reads}")
cat.cursor().executemany("INSERT INTO meta.lineage VALUES (%s, %s, 'view') ON CONFLICT DO NOTHING",
[(col, view) for col in reads])
cat.cursor().executemany("INSERT INTO meta.columns VALUES (%s, %s) ON CONFLICT DO NOTHING",
[(view, c) for c in obj["columns"] or []])
pii_sources = [col for col in reads if is_pii(cat, col)]
if pii_sources:
tag(cat, eid, "pii_propagation", view, f"читает {', '.join(pii_sources)}")
cat.execute(f"REVOKE SELECT ON {view} FROM analyst")
act(cat, eid, "pii_propagation", view, "REVOKE SELECT FROM analyst")
def on_dropped(cat: psycopg.Connection, eid: int, objects: list[dict]) -> None:
dropped = [o["identity"] for o in objects]
for o in objects:
how = "назван в команде" if o["original"] else "снесён каскадом"
print(f" удалён {o['type']} {o['identity']} ({how})")
# Обход lineage вниз от удалённых объектов. Граф хранится в каталоге: из pg_depend зависимости
# удалённого представления уже исчезли вместе с ним
rows = cat.execute(
"""
WITH RECURSIVE down(asset, path) AS (
SELECT d, d FROM unnest(%s::text[]) AS d
UNION
SELECT l.downstream, down.path || ' -> ' || l.downstream
FROM meta.lineage l
JOIN down ON l.upstream = down.asset OR starts_with(l.upstream, down.asset || '.')
)
-- до потребителя можно дойти несколькими путями, берём самый длинный
SELECT DISTINCT ON (d.asset) d.asset, d.path FROM down d
JOIN meta.lineage l ON l.downstream = d.asset AND l.kind = 'consumer'
ORDER BY d.asset, length(d.path) DESC
""",
(dropped,),
).fetchall()
for consumer, path in rows:
act(cat, eid, "impact_on_drop", consumer, f"АЛЕРТ владельцу: сломан источник, путь {path}")
if not rows:
print(" внешних потребителей ниже по lineage нет")
# граф чистится от удалённого
for asset in dropped:
cat.execute("DELETE FROM meta.lineage WHERE upstream = %s OR starts_with(upstream, %s) OR downstream = %s",
(asset, asset + ".", asset))
cat.execute("DELETE FROM meta.columns WHERE relation = %s", (asset,))
def handle(cat: psycopg.Connection, eid: int) -> None:
event, tag_, app, objects, lag_ms = cat.execute(
"SELECT event, tag, app, objects, round(extract(epoch FROM clock_timestamp() - at) * 1000) "
"FROM meta.events WHERE id = %s", (eid,)
).fetchone()
stats["events"] += 1
idents = ", ".join(f"{o['type']} {o['identity']}" for o in objects)
print(f" событие #{eid} {event} {tag_} от {app}: {idents} (через {lag_ms:.0f} мс после записи)")
# фильтр: своё событие (REVOKE слушателя) не обрабатываем, иначе правило может запустить само себя
if app == SELF_APP:
stats["self"] += 1
print(" пропущено фильтром: событие порождено действием самого слушателя")
return
if event == "sql_drop":
on_dropped(cat, eid, objects)
return
for obj in objects:
if obj["type"] == "table":
on_table_changed(cat, eid, obj)
elif obj["type"] == "view":
on_view_created(cat, eid, obj)
def run_step(sql: str, ddl: psycopg.Connection, listener: psycopg.Connection, cat: psycopg.Connection) -> None:
print(f"\n>>> {sql}")
ddl.execute(sql)
# обработка идёт по мере прихода уведомлений; секунда тишины значит, что шаг отработан
for n in listener.notifies(timeout=1.0):
handle(cat, int(n.payload))
def check_access(conn: psycopg.Connection, relations: list[str]) -> None:
for rel in relations:
try:
with conn.transaction():
conn.execute("SET LOCAL ROLE analyst")
cnt = conn.execute(f"SELECT count(*) FROM {rel}").fetchone()[0]
print(f" analyst SELECT {rel}: ok, строк {cnt}")
except psycopg.errors.InsufficientPrivilege as e:
print(f" analyst SELECT {rel}: {e.diag.message_primary}")
def main() -> None:
admin = connect("demo_reset")
reset(admin)
cat = connect(SELF_APP) # каталог: читает события, пишет граф, выполняет действия
bootstrap(cat)
listener = connect(SELF_APP)
listener.execute(f"LISTEN {CHANNEL}")
ddl = connect("etl_migration") # чужие изменения: миграции, аналитики, dbt
print("=== Правила работают, пока идут миграции ===")
t0 = time.monotonic()
run_step("ALTER TABLE raw.customers ADD COLUMN email text", ddl, listener, cat)
ddl.execute("UPDATE raw.customers SET email = lower(name) || '@example.com'")
run_step("CREATE VIEW mart.customers_by_city AS SELECT city, count(*) AS customers FROM raw.customers GROUP BY city",
ddl, listener, cat)
run_step("CREATE VIEW mart.customer_contacts AS SELECT id, name, email FROM raw.customers", ddl, listener, cat)
run_step("CREATE VIEW report.newsletter AS SELECT name, email FROM mart.customer_contacts WHERE email IS NOT NULL",
ddl, listener, cat)
print("\n=== Доступ аналитика после действий ===")
check_access(ddl, ["mart.customers_by_city", "mart.customer_contacts", "report.newsletter"])
print("\n=== Окно до действия: между записью события и REVOKE ===")
for asset, ms in cat.execute(
"SELECT a.asset, round(extract(epoch FROM a.at - e.at) * 1000) FROM meta.actions a "
"JOIN meta.events e ON e.id = a.event WHERE a.action LIKE 'REVOKE%' ORDER BY a.id"
):
print(f" {asset}: {ms:.0f} мс, в это время analyst мог читать pii")
run_step("ALTER TABLE raw.customers DROP COLUMN city CASCADE", ddl, listener, cat)
print(f"\n=== Итог за {time.monotonic() - t0:.1f} с ===")
print(f"событий {stats['events']}, из них своих отсечено {stats['self']}, действий {stats['actions']}")
print("теги:")
for asset, source in cat.execute("SELECT asset, source FROM meta.tags ORDER BY at"):
print(f" pii {asset:<28} {source}")
print("lineage в каталоге:")
for up, down, kind in cat.execute("SELECT upstream, downstream, kind FROM meta.lineage ORDER BY kind, 1, 2"):
print(f" {up} -> {down} ({kind})")
for c in (admin, cat, listener, ddl):
c.close()
if __name__ == "__main__":
main()
# фрагмент run_output.txt: active_actions.py, PostgreSQL 18.6 и psycopg 3.3.8, прогон на стенде 2026-11-13 19:47 UTC
=== Правила работают, пока идут миграции ===
>>> ALTER TABLE raw.customers ADD COLUMN email text
событие #1 ddl_command_end ALTER TABLE от etl_migration: table raw.customers (через 7 мс после записи)
сравнение с каталогом: добавлены ['email'], удалены []
-> [pii_by_name] raw.customers.email: тег pii (имя колонки совпало с (email|phone|passport|birth_date))
>>> CREATE VIEW mart.customers_by_city AS SELECT city, count(*) AS customers FROM raw.customers GROUP BY city
событие #2 ddl_command_end CREATE VIEW от etl_migration: view mart.customers_by_city (через 7 мс после записи)
lineage: mart.customers_by_city читает ['raw.customers.city']
>>> CREATE VIEW mart.customer_contacts AS SELECT id, name, email FROM raw.customers
событие #3 ddl_command_end CREATE VIEW от etl_migration: view mart.customer_contacts (через 7 мс после записи)
lineage: mart.customer_contacts читает ['raw.customers.email', 'raw.customers.id', 'raw.customers.name']
-> [pii_propagation] mart.customer_contacts: тег pii (читает raw.customers.email)
-> [pii_propagation] mart.customer_contacts: REVOKE SELECT FROM analyst
событие #4 ddl_command_end REVOKE от active_metadata: TABLE None (через 13 мс после записи)
пропущено фильтром: событие порождено действием самого слушателя
>>> CREATE VIEW report.newsletter AS SELECT name, email FROM mart.customer_contacts WHERE email IS NOT NULL
событие #5 ddl_command_end CREATE VIEW от etl_migration: view report.newsletter (через 6 мс после записи)
lineage: report.newsletter читает ['mart.customer_contacts.email', 'mart.customer_contacts.name']
-> [pii_propagation] report.newsletter: тег pii (читает mart.customer_contacts.email, mart.customer_contacts.name)
-> [pii_propagation] report.newsletter: REVOKE SELECT FROM analyst
событие #6 ddl_command_end REVOKE от active_metadata: TABLE None (через 13 мс после записи)
пропущено фильтром: событие порождено действием самого слушателя
=== Доступ аналитика после действий ===
analyst SELECT mart.customers_by_city: ok, строк 2
analyst SELECT mart.customer_contacts: permission denied for view customer_contacts
analyst SELECT report.newsletter: permission denied for view newsletter
=== Окно до действия: между записью события и REVOKE ===
mart.customer_contacts: 42 мс, в это время analyst мог читать pii
report.newsletter: 40 мс, в это время analyst мог читать pii
>>> ALTER TABLE raw.customers DROP COLUMN city CASCADE
событие #7 sql_drop ALTER TABLE от etl_migration: table column raw.customers.city, view mart.customers_by_city (через 7 мс после записи)
удалён table column raw.customers.city (назван в команде)
удалён view mart.customers_by_city (снесён каскадом)
-> [impact_on_drop] bi.city_dashboard: АЛЕРТ владельцу: сломан источник, путь raw.customers.city -> mart.customers_by_city -> bi.city_dashboard
событие #8 ddl_command_end ALTER TABLE от etl_migration: table raw.customers (через 35 мс после записи)
сравнение с каталогом: добавлены [], удалены ['city']
=== Итог за 5.1 с ===
событий 8, из них своих отсечено 2, действий 6
теги:
pii raw.customers.email имя колонки совпало с (email|phone|passport|birth_date)
pii mart.customer_contacts читает raw.customers.email
pii report.newsletter читает mart.customer_contacts.email, mart.customer_contacts.name
lineage в каталоге:
report.newsletter -> crm.mailing_job (consumer)
mart.customer_contacts.email -> report.newsletter (view)
mart.customer_contacts.name -> report.newsletter (view)
raw.customers.email -> mart.customer_contacts (view)
raw.customers.id -> mart.customer_contacts (view)
raw.customers.name -> mart.customer_contacts (view)
--- active_actions.py шёл 5 с, rc=0
Тег прошёл по цепочке в два звена, от raw.customers.email к mart.customer_contacts и дальше к report.newsletter. Аналитик потерял доступ к обоим представлениям, а агрегат mart.customers_by_city остался открыт. Каждый REVOKE вернулся событием, это #4 и #6 с типом объекта TABLE и пустым именем, и только фильтр по отправителю не дал правилу обработать собственное действие. Окно между записью события и отзывом прав составило 42 и 40 мс, а до свободного слушателя событие доходило за 6-13 мс.
Удаление колонки city снесло каскадом mart.customers_by_city, и событие sql_drop различило эти два объекта по признаку original. Обход шёл по meta.lineage, потому что зависимости снесённого представления исчезли из pg_depend вместе с ним, и граф lineage поэтому надо хранить отдельно от источника. Кроме того, тег на report.newsletter поставлен на всё представление, хотя колонка name персональными данными не является. PostgreSQL знает, какие колонки представление читает, но не знает, какую колонку вывода из них строит, и для точности нужен lineage на уровне колонок.
Заключение
Active metadata превращает каталог из справочника в участника процессов, где изменение порождает событие, правило решает, что делать, а действие меняет систему и возвращает результат в граф. Демо на PostgreSQL показывает и силу подхода, и его цену. Промежуточные изменения не теряются, тег сам идёт по lineage, удаление колонки сразу указывает на сломанный дашборд, но взамен нужны журнал событий, фильтр собственных действий и точный lineage. Начинать стоит с одного правила с понятной ценой ошибки, например с анализа влияния при удалении колонок.


