metrics

type AuthnHooksRecorder ¶ added in v0.2.0

type AuthnHooksRecorder struct {
	// contains filtered or unexported fields
}

AuthnHooksRecorder — приёмник исходов полосы. Форма метода [HookServed] совпадает с портом полосы (`iamhooks.LaneObserver`), поэтому корень отдаёт приёмник ей напрямую.

func (a *AuthnHooksRecorder) HookServed(route, outcome string)

type AuthzObservation ¶

type AuthzObservation struct {
	// RPC — полоса, которой задан вопрос. Значения — ЗАКРЫТЫЙ словарь
	// [DeclaredAuthzLanes]; каждое обязано иметь производителя, и это держит
	// проба `TestEveryDeclaredLaneHasAProducer`. Прежняя редакция называла
	// значения в этом комментарии, и одно из двух названных не производилось
	// ничем: полоса присутствовала нулём и выглядела исправным наблюдением.
	RPC      string
	Allowed  bool    // decision allowed
	Err      bool    // backend/validation error (overrides allow/deny in the decision counter)
	Duration float64 // seconds
}

AuthzObservation is a single recorded authz Check outcome.

type BindingMaterializationRecorder ¶

type BindingMaterializationRecorder struct {
	// contains filtered or unexported fields
}

BindingMaterializationRecorder measures HOW BIG one binding's materialization is: how many objects its selectors matched, and how many tuples those objects produce.

WHY THIS IS MEASURED AT ALL. Access below the three cascading levels is materialized PER OBJECT, so a single grant expands into as many tuples as the selector matches objects, times the verbs the rule carries. Nothing counted that expansion, which made "this grant grew large" indistinguishable from "this grant is ordinary" — right up until the size stops fitting whatever the model can hold. And it does not stop there where the grant was issued: the expansion is written by the reconciler, so the wall is hit later, on somebody else's request, by a path that never mentions the binding.

WHY NO CEILING IS ENFORCED HERE. The size a binding may reach has not been measured, and a limit picked before the measurement would either refuse legitimate grants or sit above everything and refuse nothing — the second being the more expensive mistake, because it looks like a control. So: measure first, then decide the number. This recorder is the measurement; it refuses nothing.

WHY HISTOGRAMS AND NOT GAUGES. The question is a distribution — «how large do bindings get, and is the tail moving?» — not a last-value. A gauge would report whichever binding the reconciler happened to touch last, which answers nothing about the tail that matters. Buckets are exponential and reach four figures, so a binding an order of magnitude past the ordinary lands in its own bucket rather than in `+Inf` together with everything else large.

The label set is EMPTY on purpose: binding id, scope and role would be unbounded cardinality straight from tenant data. The distribution answers the question; naming the individual binding is the job of the trail the reconciler already writes.

func (rec *BindingMaterializationRecorder) ObserveBindingMaterialization(objects, tuples int)

type BootstrapAdminRecorder ¶

type BootstrapAdminRecorder struct {
	// contains filtered or unexported fields
}

BootstrapAdminRecorder — исходы попыток посева доступа кластерного администратора, по одной попытке согласователя старта.

Зачем это существует ¶

Согласователь посева объявлен незавершающим ПО КОНТРАКТУ: он повторяет попытку бессрочно, подъём не задерживает и на неисполнимом посеве печатает `Debug`. При рабочем уровне `Info` это не печатается вовсе — то есть «доступ администратора не выдан НИ РАЗУ за всю жизнь стенда» снаружи неотличимо от «выдан на первой же попытке».

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

Почему ряды заводятся ЗАРАНЕЕ, а не вместе с первым событием ¶

Счётчик, у которого полоса появляется вместе с первым попаданием, на стенде без единой выдачи ряда `granted` НЕ ИМЕЕТ. Отсутствующий ряд снаружи неотличим от отсутствующего согласователя — то есть от той самой тишины, ради снятия которой счётчик заведён. Поэтому все полосы объявленного набора инициализируются нулём при регистрации: «ноль выдач» становится НАБЛЮДАЕМЫМ фактом, а не отсутствием факта.

Почему числитель считается вместе со знаменателем ¶

Счётчик одних отказов не отличает «отказов не было» от «попыток не было». Полосы пропуска и полоса выдачи растут в одном счётчике, поэтому вопрос «работает ли посев вообще» отвечается их суммой, а вопрос «выдан ли доступ» — одной полосой.

Набор меток ЗАКРЫТ: `outcome` приходит из констант согласователя (seed.BootstrapOutcomes), никогда из запроса, поэтому кардинальность не растёт ни с трафиком, ни с числом арендаторов.

func (rec *BootstrapAdminRecorder) IncBootstrapAdminAttempt(outcome string)

type CatalogSnapshotRecorder ¶

type CatalogSnapshotRecorder struct {
	// contains filtered or unexported fields
}

CatalogSnapshotRecorder — исходы ОБНОВЛЕНИЯ снимка каталога модуля (kacho#1816, IAM-CT-2-03 / -04).

Зачем считать УСПЕХИ, а не только отказы ¶

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

Зачем считать отказы, если успехи уже считаются ¶

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

Чем это отличается от заполнения на СТАРТЕ ¶

Заполнение снимка на старте здесь НЕ считается: оно идёт тем же чтением, что и страж паритета, и его отказ фатален — служба не поднимается. Зачти его — и «ноль обновлений за жизнь процесса» станет неотличимо от одного.

Набор меток ЗАКРЫТ: outcome приходит из констант пакета `catalog` (refreshed|failed), никогда из запроса, поэтому кардинальность не растёт с трафиком.

func (rec *CatalogSnapshotRecorder) IncCatalogSnapshotRefresh(outcome string)

type CompensationRecorder ¶

type CompensationRecorder struct {
	// contains filtered or unexported fields
}

CompensationRecorder — счётчики компенсаций частично исполненной саги «зарегистрировать клиента у провайдера → закоммитить свою строку».

Состояние самой очереди (глубина, возраст головы, отравленные) здесь БОЛЬШЕ НЕ живёт: гейджи размечены лейблом `table` и годятся любой очереди сервиса, а очередей у сервиса НЕСКОЛЬКО — держать их в типе с именем «компенсация» значило бы объявлять областью действия одну. Числа здесь нет намеренно: оно росло молча (в день заведения комментарий говорил «три»), а перечень выводится предикатом — см. шапку OutboxRecorder в outbox_recorder.go. Они переехали в OutboxRecorder (outbox_recorder.go), который наблюдает все три.

ЗАЧЕМ СЧЁТЧИК, А НЕ ТОЛЬКО ЛОГ. Компенсация срабатывает редко и только на неудачном пути, поэтому «ноль компенсаций за всю жизнь» — нормальное состояние здорового облака И одновременно ровно то, что видно у мёртвого механизма: очередь не провязана, дренаж не поднят, applier никогда не звали. Отличить их можно только если считать ЗАПИСАННЫЕ намерения отдельно от ИСПОЛНЕННЫХ: серия, которой нет вовсе, отвечает на «провязано ли», а расхождение записанных и исполненных — на «доезжает ли». То же требование, что и «ноль доставленных строк за всю жизнь очереди обязано быть заметно».

На второй обязательный вопрос — «висит ли ЭТА строка дольше N» — отвечает возраст головы очереди из OutboxRecorder. Обе величины нужны, ни одна не заменяет другую: расхождение записанных и исполненных говорит «доезжает ли вообще», возраст — «застряла ли конкретная».

Набор меток ЗАКРЫТ: origin приходит из констант use-case'ов (sa_key|user_token|interactive_client), никогда из запроса, поэтому кардинальность не растёт с трафиком.

func (rec *CompensationRecorder) IncCompensationApplied(origin string)

func (rec *CompensationRecorder) IncCompensationEmitted(origin, outcome string)

type ExpiredCredentialSweepRecorder ¶ added in v0.2.0

type ExpiredCredentialSweepRecorder struct {
	// contains filtered or unexported fields
}

ExpiredCredentialSweepRecorder — приёмник величин второго уборщика. Форма метода [SweepObserved] совпадает с портом уборщика (`expiredcredsweep.Observer`), поэтому корень отдаёт приёмник ему напрямую.

func (x *ExpiredCredentialSweepRecorder) SetEnabled(on bool)

func (x *ExpiredCredentialSweepRecorder) SweepObserved(outcome string, found, reclaimed int)

type IdentityGrowthCounts ¶

type IdentityGrowthCounts struct {
	// IdentitiesEverSeen — рядов в накопительном журнале.
	IdentitiesEverSeen int64
	// SamplesOK — успешных замеров за жизнь процесса.
	SamplesOK uint64
	// SamplesFailed — отказавших замеров за жизнь процесса.
	SamplesFailed uint64
}

IdentityGrowthCounts — то, что витрина читает у замерщика.

type InstrumentedAuthorizer ¶

type InstrumentedAuthorizer struct {
	// contains filtered or unexported fields
}

InstrumentedAuthorizer decorates a relationAuthorizer, recording the authz Check hot-path histogram + decision counter for every CheckRelation call. It is a pass-through: the wrapped result/error are returned verbatim, so the decision logic in the use-case is unaffected.

func NewInstrumentedAuthorizer(inner relationAuthorizer, reg *Registry) *InstrumentedAuthorizer

func (d *InstrumentedAuthorizer) CheckRelation(ctx context.Context, req service.CheckRelationRequest) (*service.CheckResult, error)

type InstrumentedSubjectAuthorizer ¶

type InstrumentedSubjectAuthorizer struct {
	// contains filtered or unexported fields
}

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

Наблюдает ДВЕ полосы (край и сужатель) и не трогает ничего больше: результат и ошибка возвращаются дословно, поэтому решение остаётся решением use-case. Остальные методы порта проходят насквозь без наблюдения — у них своя цена и свой предмет, и приписывать их к «проверкам» значило бы завысить число ровно так же, как раньше оно было занижено.

func NewInstrumentedSubjectAuthorizer(inner subjectAuthorizer, reg *Registry) *InstrumentedSubjectAuthorizer

func (d *InstrumentedSubjectAuthorizer) BatchCheck(ctx context.Context, reqs []service.CheckRequest) ([]*service.CheckResult, error)

func (d *InstrumentedSubjectAuthorizer) Check(ctx context.Context, req service.CheckRequest) (*service.CheckResult, error)

func (d *InstrumentedSubjectAuthorizer) ExpandRelations(ctx context.Context, req service.ExpandRequest) (*service.ExpandResult, error)

func (d *InstrumentedSubjectAuthorizer) ListSubjects(ctx context.Context, req service.ListSubjectsRequest) (*service.ListSubjectsResult, error)

type IntrospectCounts ¶

type IntrospectCounts struct {
	Active      uint64
	Inactive    uint64
	Unavailable uint64
}

IntrospectCounts — величины авторитета отзыва.

type InviteActivationRecorder ¶

type InviteActivationRecorder struct {
	// contains filtered or unexported fields
}

InviteActivationRecorder — исходы активации приглашения на первом входе.

Зачем считать УСПЕХИ, а не только отказы ¶

Счётчик одних отказов не отличает «отказов не было» от «активаций не было вовсе»: и там и там ноль. Путь, умерший целиком, выглядел бы здоровее всех (security.md §Hardening-инварианты п.8 — «ноль за всю жизнь» обязано быть заметно). Поэтому исходов три, и знаменатель считается наравне с числителем.

Почему гонка — отдельный исход, а не отказ ¶

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

Набор меток ЗАКРЫТ: outcome приходит из констант use-case'а (activated|already_active|failed), никогда из запроса, поэтому кардинальность не растёт с трафиком.

func (rec *InviteActivationRecorder) IncInviteActivation(outcome string)

type InviteMailRecorder ¶

type InviteMailRecorder struct {
	// contains filtered or unexported fields
}

InviteMailRecorder — счётчик исходов отправки письма приглашения.

ПОЧЕМУ СДАННЫЕ СЧИТАЮТСЯ НАРАВНЕ С ОТКАЗАМИ ¶

Форма взята у зеркала набора ключей вместе с её обоснованием (приёмка ID-MAIL-1, Р25). Пока наружу выходят одни отказы, ноль в них отвечает сразу на два вопроса — «отказов не было» и «сюда никто не приходил», — а различие между ними и есть различие между работающим отправителем и мёртвым. Реальный прецедент проекта: очередь регистраций, у которой за всю жизнь не доехало ни одной строки, и это было ненаблюдаемо, потому что синхронный путь работал.

ПОЧЕМУ НАСТРОЙКА — СВОЯ КЛЕТКА, А НЕ ВИД ОТКАЗА ¶

Недоступность узла проходит со временем; ответ не по протоколу почты по объявленному адресу не проходит никогда. Смешать их в одном ряду значит спрятать настройку под сбой и сделать постоянную неверную настройку штатным режимом (`security.md` §Hardening п. 8).

ГРАНИЦА УТВЕРЖДЕНИЯ НАЗВАНА ЗДЕСЬ, А НЕ ВЫВЕДЕНА ЧИТАТЕЛЕМ ¶

Счётчик считает НАШИ отправки — письма приглашения. О письмах подтверждения адреса и восстановления доступа он не утверждает НИЧЕГО: их отправляет чужой процесс, чьи величины из нашего дерева не измеримы вовсе. Счётчик, названный «письма продукта» и считающий одну полосу, — то же «принято-и-проигнорировано», только заведённое собственными руками: читатель получил бы величину, которая говорит меньше, чем её имя. Поэтому имя семейства называет ПРИГЛАШЕНИЕ.

ЧТО ЗНАЧИТ «СДАНО» ¶

Сдано РЕТРАНСЛЯТОРУ, а не получено адресатом. Дальше ретранслятора наш вердикт не идёт, и продукт нигде не утверждает доставку (Р15). Читать эту клетку как «доставлено» — ошибка, которую этот текст и закрывает.

ВТОРАЯ ОБЯЗАТЕЛЬНАЯ ВЕЛИЧИНА ЖИВЁТ НЕ ЗДЕСЬ ¶

«Висит ли ЭТА строка дольше N» отвечает возраст головы очереди из OutboxRecorder (`outbox_oldest_pending_age_seconds{table}`), который ведёт периодический скан очереди. Обе величины нужны, ни одна не заменяет другую: расхождение исходов говорит «доезжает ли вообще», возраст — «застряла ли конкретная».

func (rec *InviteMailRecorder) IncInviteMailOutcome(outcome string)

type JWKSMirrorCounts ¶

type JWKSMirrorCounts struct {
	// Served — обращений к верхнему хопу, давших набор ключей.
	Served uint64
	// Unavailable — отказов, потому что верхний хоп не ответил полезно.
	Unavailable uint64
	// Misconfigured — отказов, потому что по адресу не набор ключей.
	Misconfigured uint64
}

JWKSMirrorCounts — три числа зеркала ключей, прочитанные у самого зеркала.

type LRORecorder ¶

type LRORecorder struct {
	// contains filtered or unexported fields
}

LRORecorder is the Prometheus implementation of operations.Recorder. Without it the operations default-registry keeps a NopRecorder, so the live LRO-worker signals (terminal-write retries/failures, the in-flight gauge, orphan recovery, reconcile runs/errors) — the exact signals for a stranding operation — are invisible on /metrics. Wired once at the composition root via ConfigureDefault.

func (l *LRORecorder) IncOrphansRecovered(outcome string)

func (l *LRORecorder) IncReconcileErrors()

func (l *LRORecorder) IncReconcileRuns()

func (l *LRORecorder) IncTerminalWriteFailures(opType string)

func (l *LRORecorder) IncTerminalWriteRetries(opType string)

func (l *LRORecorder) SetInflight(n float64)

type ListScanRecorder ¶

type ListScanRecorder struct {
	// contains filtered or unexported fields
}

ListScanRecorder снимает стоимость одной отданной страницы списка.

func (r *ListScanRecorder) ObserveListScan(_ context.Context, resource string, rows, checks int)

type ModuleCatalogRecorder ¶

type ModuleCatalogRecorder struct {
	// contains filtered or unexported fields
}

ModuleCatalogRecorder — что сделало ПРИМЕНЕНИЕ каталога модуля (`modulecatalog.Applier`, задача продукта #1963).

Зачем метрика, если перепись уже печатается журналом ¶

Перепись печатается на старте, и число оператору достаётся — если он этот журнал читает. В три часа ночи вопрос стоит иначе, чем при разборе: «каталог отстал» или «продукт сломан». Журнал отвечает после того, как найден нужный под, нужный старт и нужная строка; счётчик отвечает сразу.

Величин ТРИ, и одной не хватает ни на один из трёх вопросов ¶

применений ноль    → применитель не ходил вовсе (знаменатель)
снятий ноль        → каталог не менялся
переселений ноль   → снятие БЫЛО, но ни одной роли не задело

Оставь одни переселения — и ноль будет означать сразу три разных состояния, из которых одно (мёртвый применитель) выглядело бы здоровее всех. Сложи снятия с переселениями — и потеряешь различие, ради которого перепись применителя и держит две популяции порознь: «право отобрано» (`role_verb`) и «правило перестало резолвиться» (`rule_ref`) — разные события для того, кто разбирает последствия.

Граница названа: отказ на пути СТАРТА этой метрикой не наблюдаем ¶

Исход `failed` производителя имеет — его эмитит всякий отказ применения, — но на пути старта он неснимаем by construction: отказ применения есть отказ пуска, а слушатель метрик поднимается позже применителя, и процесс до него не доживает. Наблюдают такой отказ по отсутствию процесса и по журналу; серия нужна второму вызывающему глагола, который отказ переживает.

Наборы меток ЗАКРЫТЫ ¶

Все три приходят из констант `modulecatalog` (applied|failed, resource|verb, rule_ref|role_verb), никогда из запроса, поэтому кардинальность не растёт с трафиком.

func (rec *ModuleCatalogRecorder) AddCatalogResettledProjections(population string, n int)

func (rec *ModuleCatalogRecorder) AddCatalogRetiredRows(kind string, n int)

func (rec *ModuleCatalogRecorder) IncCatalogApply(outcome string)

type OutboxRecorder ¶

type OutboxRecorder struct {
	// contains filtered or unexported fields
}

OutboxRecorder — состояние ВСЕХ очередей kaname, снимаемое периодическим сканом таблицы, а не логом дренажа.

Почему это отдельный тип, а не поля в CompensationRecorder ¶

Гейджи ниже размечены лейблом `table` и потому годятся любой очереди сервиса — но жили они в типе с именем «компенсация», хотя компенсация — ОДНА из очередей сервиса, а не все они. Числа очередей здесь намеренно НЕТ: оно росло у этого комментария молча (в день заведения он говорил «три», и это перестало быть верным задолго до того, как кто-нибудь перечитал строку). Перечень ВЫВОДИТСЯ:

git grep -c 'CREATE TABLE kaname\..*outbox' -- services/iam/internal/migrations
git grep -l 'outboxmetrics.NewCollector' -- services/iam/cmd ':!*_test.go'

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

Второй предикат сужен до композиционного корня НЕ для краткости: без сужения он находит ЭТОТ ЖЕ комментарий и считает собственное объяснение за наблюдателя (замерено: 4 файла вместо 3). Проверка, считающая собственную прозу, — тот самый класс, ради которого предикат вообще пишут рядом с числом; поэтому он смотрит туда, где наблюдателей ПРОВЯЗЫВАЮТ, а не туда, где о них пишут. Имя типа читается как область его действия: следующий, кому понадобится наблюдать fga_outbox, увидел бы «это про компенсации» и завёл бы вторые гейджи с теми же именами — то есть уронил бы старт на duplicate-register ровно тогда, когда механизм наконец провязали целиком. Поэтому счётчики компенсации остались у компенсации, а состояние очередей вынесено сюда и берётся одним экземпляром на реестр.

Что здесь есть и почему именно это ¶

Сводные серии по таблице:

kaname_outbox_backlog_depth{table}              — недоставленных строк
kaname_outbox_oldest_pending_age_seconds{table} — возраст головы очереди
kaname_outbox_poisoned_count{table}             — отравленных сейчас

Плюс разложение той же очереди ПО НАПРАВЛЕНИЮ:

kaname_outbox_backlog_depth_by_direction{table,direction}
kaname_outbox_oldest_pending_age_by_direction_seconds{table,direction}
kaname_outbox_delivered_total{table,direction}

Разложение нужно потому, что сводные серии на очереди с двумя половинами остаются здоровыми при полностью мёртвой второй: выдачи прав идут непрерывно — ресурсы создают всё время, — поэтому и глубина мала, и голова молода, что бы ни происходило со снятием. «Работает» и «ни разу не отозвано» дают ОДИНАКОВУЮ картину, и различает их только `delivered_total{direction="withdrawal"}`: единственная из четырёх величин, которая отличает «их не было» от «они не доезжают».

Набор меток ЗАКРЫТ: имена таблиц и направлений приходят из констант composition root, никогда из запроса, поэтому кардинальность не растёт с трафиком.

func (rec *OutboxRecorder) IncDeliveredByDirection(table, direction string)

func (rec *OutboxRecorder) IncPoisoned(table string)

func (rec *OutboxRecorder) InitDeliveredByDirection(table, direction string)

func (rec *OutboxRecorder) InitScanOutcomes(table string)

func (rec *OutboxRecorder) ObserveScanFailure(table string)

func (rec *OutboxRecorder) SetBacklogDepth(table string, depth float64)

func (rec *OutboxRecorder) SetBacklogDepthByDirection(table, direction string, depth float64)

func (rec *OutboxRecorder) SetOldestPendingAgeByDirection(table, direction string, age float64)

func (rec *OutboxRecorder) SetOldestPendingAgeSeconds(table string, age float64)

func (rec *OutboxRecorder) SetPoisonedCount(table string, count float64)

type OwnKeySetCounts ¶

type OwnKeySetCounts struct {
	Served      uint64
	Unavailable uint64
	Empty       uint64
}

OwnKeySetCounts — величины нашей записи набора, прочитанные у публикатора.

type PresentedCredentialCounts ¶

type PresentedCredentialCounts struct {
	Accepted    uint64
	Refused     uint64
	Unavailable uint64
}

PresentedCredentialCounts — величины читателя предъявленного.

type ReadinessRecorder ¶ added in v0.2.0

type ReadinessRecorder struct {
	// contains filtered or unexported fields
}

ReadinessRecorder — приёмник исхода готовности. Форма метода [Observe] совпадает с объявленной опцией носителя (`health.WithResultObserver`), поэтому корень отдаёт приёмник ей напрямую и своего переходника не заводит.

func (o *ReadinessRecorder) Observe(dependency string, up bool)

type RegisterPostCommitRecorder ¶

type RegisterPostCommitRecorder struct {
	// contains filtered or unexported fields
}

RegisterPostCommitRecorder counts the POST-COMMIT accelerators of the cross-service registration path — the forward reconcile that materializes the owner's per-object access, and the direct apply of the containment pointer.

WHY A COUNTER AND NOT JUST THE LOG LINE. Both steps are best-effort by design: they front a durable queue, so a failure costs latency and never the change itself. That is exactly what makes a permanently broken one invisible — one WARN per occurrence, a product that keeps working more slowly, and nothing that says so. A control that has never refused in its whole life is indistinguishable from one that was never reached unless RUNS are counted alongside OUTCOMES (security.md §Hardening-инвариант 8, the same requirement as "zero rows ever delivered" for a queue).

WHY EVERY CELL STARTS AT ZERO RATHER THAN APPEARING ON FIRST USE. An absent series answered two different questions at once — "this step never ran" and "this collector is not wired at all" — and telling those apart is the whole point. Measured on a stand: the ADDITIVE forward entry fired ZERO times across 367 registrations, and that was establishable only because its sibling had a series; on its own the proven entry looked like code that does not exist. With the closed label set initialised at construction, presence answers "is it wired?" and the VALUE answers "was it ever reached?" — so `forward_additive == 0` beside a growing `forward_guarded` is a FINDING stated by the metric, not a silence somebody has to interpret.

The `step` label additionally exposes WHICH materialization path each registration took. That is not decoration: `forward_additive` is the fast path a redelivery is supposed to stay on, and `forward_guarded` is the one that may escalate to the FULL EXCLUSIVE recompute every object of an account queues behind. A regression that pushes registrations back onto the guarded path shows up as a shift between two series, rather than as a latency somebody has to notice.

The label set is CLOSED and declared once above — the count is not repeated in prose here, because the prose already drifted from the code once.

func (rec *RegisterPostCommitRecorder) ObserveRegisterPostCommit(step, outcome string)

type Registry ¶

type Registry struct {
	// contains filtered or unexported fields
}

Registry owns a private *prometheus.Registry and the kaname collectors. It is created once in the composition root and shared by the metrics HTTP listener, the authz decorator and the gRPC interceptors. A private registry (not the global default) keeps tests hermetic and avoids duplicate-register panics across server restarts in the same process (integration tests).

func NewRegistry() *Registry

func (r *Registry) AuthnHooksRecorder(routes, outcomes []string) *AuthnHooksRecorder

func (r *Registry) CompensationRecorder() *CompensationRecorder

func (r *Registry) ExpiredCredentialSweepRecorder(outcomes []string) *ExpiredCredentialSweepRecorder

func (r *Registry) Handler() http.Handler

func (r *Registry) InviteActivationRecorder() *InviteActivationRecorder

func (r *Registry) InviteMailRecorder() *InviteMailRecorder

func (r *Registry) NewBindingMaterializationRecorder() *BindingMaterializationRecorder

func (r *Registry) NewBootstrapAdminRecorder() *BootstrapAdminRecorder

func (r *Registry) NewCatalogSnapshotRecorder() *CatalogSnapshotRecorder

func (r *Registry) NewClientTokenOutcomeCollector(outcomes []string, read func() map[string]uint64)

func (r *Registry) NewCompensationRecorder() *CompensationRecorder

func (r *Registry) NewIdentityGrowthCollector(read func() IdentityGrowthCounts)

func (r *Registry) NewInviteActivationRecorder() *InviteActivationRecorder

func (r *Registry) NewInviteMailRecorder() *InviteMailRecorder

func (r *Registry) NewJWKSMirrorCollector(read func() JWKSMirrorCounts)

func (r *Registry) NewLRORecorder() *LRORecorder

func (r *Registry) NewListScanRecorder() *ListScanRecorder

func (r *Registry) NewModuleCatalogRecorder() *ModuleCatalogRecorder

func (r *Registry) NewOwnKeySetCollector(read func() OwnKeySetCounts)

func (r *Registry) NewPresentedCredentialCollector(read func() PresentedCredentialCounts)

func (r *Registry) NewRegisterPostCommitRecorder() *RegisterPostCommitRecorder

func (r *Registry) NewRegistryTokenCredentialKindRecorder() *RegistryTokenCredentialKindRecorder

func (r *Registry) NewRelationVerdictGroundsCollector(read func() RelationVerdictGrounds)

func (r *Registry) NewRetentionCollector(read func() RetentionCounts)

func (r *Registry) NewRoleVerbReseedRecorder() *RoleVerbReseedRecorder

func (r *Registry) NewRuleRefReseedRecorder() *RuleRefReseedRecorder

func (r *Registry) NewSigningKeyCollector(read func() SigningKeyCounts)

func (r *Registry) NewTokenIntrospectionCollector(read func() IntrospectCounts)

func (r *Registry) ObserveAuthz(o AuthzObservation)

func (r *Registry) ObserveAuthzDecision(rpc string, allowed, failed bool)

func (r *Registry) ObserveAuthzDuration(rpc string, allowed bool, seconds float64)

func (r *Registry) ObserveAuthzStoreAttempt(op, outcome string, reused bool)

func (r *Registry) OutboxRecorder() *OutboxRecorder

func (r *Registry) ReadinessRecorder(dependencies []string) *ReadinessRecorder

func (r *Registry) RegisterBuildInfo(version, revision string)

func (r *Registry) RegisterPoolStats(poolName string, pool *pgxpool.Pool)

func (r *Registry) Registerer() prometheus.Registerer

func (r *Registry) RegistryTokenCredentialKindRecorder() *RegistryTokenCredentialKindRecorder

type RegistryTokenCredentialKindRecorder ¶

type RegistryTokenCredentialKindRecorder struct {
	// contains filtered or unexported fields
}

RegistryTokenCredentialKindRecorder — исходы полос предъявленного удостоверения докерной полосы `/iam/token`.

Зачем счётчик, а не строка журнала ¶

Ломающее изменение #1143 сняло приём ключевого материала в поле пароля. Причина отказа уходила в предупреждение журнала — и на вопросы, которые оператор задаёт во время перехода, предупреждение не отвечает, потому что оба вопроса КОЛИЧЕСТВЕННЫЕ:

«скольких я сломаю (сломал), если окно закрыто» → key_material_refused;
«можно ли уже закрывать окно»                   → key_material_accepted_in_window.

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

Почему исходов ТРИ, а не один ¶

Счётчик одних отказов не отличает «отказов не было» от «входов не было вовсе»: и там и там ноль, и полоса, умершая целиком, выглядела бы здоровее всех (security.md §Hardening-инварианты п.8 — «ноль за всю жизнь» обязано быть заметно). Поэтому знаменатель — basic_accepted — считается наравне с числителями.

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

Кардинальность ¶

Набор меток ЗАКРЫТ: outcome приходит из констант use-case'а (registry_token.Outcome*), никогда из запроса, — поэтому кардинальность не растёт с трафиком. Ни имени предъявителя, ни идентификатора удостоверения здесь нет: в метрику не уходит то, чего не отдают клиенту.

func (rec *RegistryTokenCredentialKindRecorder) ObserveCredentialKind(outcome string)

type RelationVerdictGrounds ¶

type RelationVerdictGrounds struct {
	// LabelArmMirror / LabelArmIAMDirect — оснований, данных меточной ветвью,
	// по осям.
	LabelArmMirror    int64
	LabelArmIAMDirect int64
	// EarlyStops — вердиктов, ответивших до того, как набор источников дочитан.
	EarlyStops int64
	// UndeclaredTypeDenials — отказов по основанию «тип не объявлен моделью».
	UndeclaredTypeDenials int64
}

RelationVerdictGrounds — снимок разбора оснований, прочитанный у самого источника вердикта.

Все четыре числа снимаются с ОДНОГО носителя и одним сбором: разнесённые по двум коллекторам, они читались бы в разные моменты, и знаменатель относился бы не к тому числителю.

type RetentionCounts ¶

type RetentionCounts struct {
	// Passes — сколько проходов исполнено за жизнь процесса.
	Passes int64
	// Removed — снято строк по каждому предмету.
	Removed map[string]int64
	// Failures — отказов прохода по каждому предмету.
	Failures map[string]int64
}

RetentionCounts — снимок накопленного уборщиком.

Зеркалит `retention.Counts`; отдельный тип здесь потому, что слой наблюдаемости не импортирует прикладной слой.

type RoleVerbReseedRecorder ¶

type RoleVerbReseedRecorder struct {
	// contains filtered or unexported fields
}

RoleVerbReseedRecorder — исходы пересчёта проекции «роль → тип объекта × глагол» на старте, по одной системной роли.

Зачем считать УСПЕХИ, а не только отказы ¶

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

Почему это отдельная полоса, а не часть досева выдач ¶

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

Набор меток ЗАКРЫТ: outcome приходит из констант досева (reseeded|failed), никогда из запроса, поэтому кардинальность не растёт с трафиком.

func (rec *RoleVerbReseedRecorder) IncRoleVerbReseed(outcome string)

type RuleRefReseedRecorder ¶

type RuleRefReseedRecorder struct {
	// contains filtered or unexported fields
}

RuleRefReseedRecorder — исходы пересчёта проекции ОБЪЯВЛЕННЫХ СЕГМЕНТОВ правила (`kaname.role_rule_ref`) на старте, по одной системной роли.

Зачем считать УСПЕХИ, а не только отказы ¶

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

Почему это ОТДЕЛЬНЫЙ счётчик, а не метка у счётчика глаголов ¶

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

Набор меток ЗАКРЫТ: outcome приходит из констант досева (reseeded|failed), никогда из запроса, поэтому кардинальность не растёт с трафиком.

func (rec *RuleRefReseedRecorder) IncRuleRefReseed(outcome string)

type SigningKeyCounts ¶

type SigningKeyCounts struct {
	Generated   uint64
	Activated   uint64
	Retired     uint64
	Removed     uint64
	Compromised uint64
	Failures    uint64
}

SigningKeyCounts — величины ключницы.