отработаны находки ревью кода
Триаж свёл 62 сырые находки девяти проходов к 33 причинам: 3 блокера, 4 «сейчас», 2 развилки. Все закрыты регрессионными тестами. - схема точки сна определяется по самой точке, а не по индексу в исходном массиве: одна пропущенная точка меняла эпизод и сводку местами - доставка сворачивается одной транзакцией: частичное состояние было недетерминированным (восемь прогонов — семь состояний) - граница размера на распакованном теле: 400 КиБ gzip разворачивались в 400 МиБ мимо max_body_mb - столкновение — расхождение канонических форм, а не байтов; WARN с координатами объекта; payload без HTML-экранирования - выравнивание по местной метке: получасовые зоны уводили часовую выгрузку в minute - доставка из одних суточных сводок больше не отвергается целиком - единицы не переписываются молча; счётчик считает сохранённые точки - все выходы Fold логируются, исход пишется на переживающем отмену контексте Четыре развилки вынесены блокерами в беклог.
This commit is contained in:
+162
-73
@@ -46,39 +46,111 @@ type Bucket struct {
|
||||
// это единственное наблюдение, по которому можно судить, работает ли правило
|
||||
// разрешения столкновений.
|
||||
type MergeStats struct {
|
||||
Buckets int
|
||||
Points int
|
||||
Buckets int
|
||||
// Stored — сколько точек ДОБАВИЛОСЬ в объекты. Не то же, что число точек в
|
||||
// доставке: точные повторы схлопываются, и счётчик присланных завышал бы
|
||||
// содержимое витрины ровно тогда, когда точки начнут теряться.
|
||||
Stored int
|
||||
Unchanged int
|
||||
Overwrites int
|
||||
SealedHits int
|
||||
// UnitsConflicts — объекты, куда точки приехали в единицах, отличных от
|
||||
// сохранённых. Молчаливая замена недопустима: внутри точки единиц нет, и
|
||||
// у ранних точек не остаётся ничего, по чему их единицы восстановимы.
|
||||
UnitsConflicts int
|
||||
// Collisions — координаты первых столкновений, для записи в лог. Без них
|
||||
// счётчик перезаписей не говорит, какая метрика и какой час пострадали.
|
||||
Collisions []Collision
|
||||
}
|
||||
|
||||
// Collision — координаты объекта, где содержимое точки было перезаписано.
|
||||
// Значений точек не несёт: данные о здоровье чувствительнее токенов.
|
||||
type Collision struct {
|
||||
Metric string
|
||||
Layer string
|
||||
HourUTC time.Time
|
||||
}
|
||||
|
||||
// maxCollisionsReported — сколько координат столкновений попадает в лог.
|
||||
// Больше горсти не нужно: они нужны как зацепка для разбора, а не как отчёт.
|
||||
const maxCollisionsReported = 5
|
||||
|
||||
// MergePoints раскладывает точки по часовым объектам и сливает их с
|
||||
// сохранёнными.
|
||||
//
|
||||
// Час берётся по НАЧАЛУ точки: интервал пересекает границы часов, и любой
|
||||
// другой выбор сделал бы принадлежность объекту зависящей от длительности.
|
||||
// Вся доставка сворачивается ОДНОЙ транзакцией, а не транзакцией на объект.
|
||||
//
|
||||
// Транзакция на объект давала недетерминированное частичное состояние: обход
|
||||
// карты групп рандомизирован, и при отказе посреди доставки набор уже
|
||||
// закоммиченных объектов каждый раз другой (измерено: восемь прогонов одной
|
||||
// доставки — семь разных состояний). Это ломает инвариант «состояние
|
||||
// пересобираемо»: пересборка из архива давала бы не то, что живой приём, а
|
||||
// хеш-детектор после расхождения переписывал бы «неизменившееся».
|
||||
//
|
||||
// Заодно снимается стоимость: отдельный коммит на объект стоил около 0.7 мс,
|
||||
// то есть 8.5 мс на килобайт тела.
|
||||
func (s *Store) MergePoints(ctx context.Context, in []IncomingPoint, deliveryID string) (MergeStats, error) {
|
||||
var stats MergeStats
|
||||
groups := groupByHour(in)
|
||||
keys := sortedKeys(groups)
|
||||
|
||||
for key, group := range groupByHour(in) {
|
||||
res, err := s.mergeBucket(ctx, key, group, deliveryID)
|
||||
if err != nil {
|
||||
return stats, err
|
||||
}
|
||||
stats.Buckets++
|
||||
stats.Points += len(group.points)
|
||||
stats.Overwrites += res.overwrites
|
||||
if res.unchanged {
|
||||
stats.Unchanged++
|
||||
}
|
||||
if res.sealed {
|
||||
stats.SealedHits++
|
||||
var stats MergeStats
|
||||
err := s.inTx(ctx, func(tx *sql.Tx) error {
|
||||
// Счётчики обнуляются на каждой попытке: повтор транзакции начинает
|
||||
// слияние заново, и накопленное от прошлой попытки посчиталось бы дважды.
|
||||
stats = MergeStats{}
|
||||
|
||||
for _, key := range keys {
|
||||
group := groups[key]
|
||||
res, err := mergeBucket(ctx, tx, key, group, deliveryID)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
stats.Buckets++
|
||||
stats.Stored += res.stored
|
||||
stats.Overwrites += res.overwrites
|
||||
if res.unchanged {
|
||||
stats.Unchanged++
|
||||
}
|
||||
if res.sealed {
|
||||
stats.SealedHits++
|
||||
}
|
||||
if res.unitsConflict {
|
||||
stats.UnitsConflicts++
|
||||
}
|
||||
if res.overwrites > 0 && len(stats.Collisions) < maxCollisionsReported {
|
||||
stats.Collisions = append(stats.Collisions, Collision{
|
||||
Metric: key.metric, Layer: key.layer, HourUTC: key.hourUTC,
|
||||
})
|
||||
}
|
||||
}
|
||||
return nil
|
||||
})
|
||||
if err != nil {
|
||||
return MergeStats{}, err
|
||||
}
|
||||
return stats, nil
|
||||
}
|
||||
|
||||
// sortedKeys задаёт детерминированный порядок обхода объектов доставки.
|
||||
func sortedKeys(groups map[bucketKey]*pointGroup) []bucketKey {
|
||||
keys := make([]bucketKey, 0, len(groups))
|
||||
for k := range groups {
|
||||
keys = append(keys, k)
|
||||
}
|
||||
sort.Slice(keys, func(i, j int) bool {
|
||||
if keys[i].metric != keys[j].metric {
|
||||
return keys[i].metric < keys[j].metric
|
||||
}
|
||||
if keys[i].layer != keys[j].layer {
|
||||
return keys[i].layer < keys[j].layer
|
||||
}
|
||||
return keys[i].hourUTC.Before(keys[j].hourUTC)
|
||||
})
|
||||
return keys
|
||||
}
|
||||
|
||||
// IncomingPoint — точка, пришедшая на запись. Отдельный тип от Point потому,
|
||||
// что несёт координаты объекта (метрику, слой, единицы), а Point живёт уже
|
||||
// внутри объекта и их не дублирует.
|
||||
@@ -119,60 +191,62 @@ func groupByHour(in []IncomingPoint) map[bucketKey]*pointGroup {
|
||||
}
|
||||
|
||||
type mergeResult struct {
|
||||
overwrites int
|
||||
unchanged bool
|
||||
sealed bool
|
||||
overwrites int
|
||||
stored int
|
||||
unchanged bool
|
||||
sealed bool
|
||||
unitsConflict bool
|
||||
}
|
||||
|
||||
// mergeBucket выполняет чтение, слияние и запись одного объекта одной
|
||||
// транзакцией.
|
||||
// mergeBucket выполняет чтение, слияние и запись одного объекта.
|
||||
//
|
||||
// Тройка обязана быть атомарной целиком: между чтением и записью может
|
||||
// вклиниться другая доставка того же часа, и её точки пропали бы молча.
|
||||
func (s *Store) mergeBucket(ctx context.Context, key bucketKey, group *pointGroup, deliveryID string) (mergeResult, error) {
|
||||
// Тройка обязана быть атомарной: между чтением и записью может вклиниться
|
||||
// другая доставка того же часа, и её точки пропали бы молча. Атомарность даёт
|
||||
// транзакция вызывающего — она общая на всю доставку.
|
||||
func mergeBucket(ctx context.Context, tx *sql.Tx, key bucketKey, group *pointGroup, deliveryID string) (mergeResult, error) {
|
||||
var res mergeResult
|
||||
|
||||
err := s.inTx(ctx, func(tx *sql.Tx) error {
|
||||
res = mergeResult{}
|
||||
|
||||
stored, found, err := readBucket(ctx, tx, key)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
merged, overwrites := mergePoints(stored.Points, group.points)
|
||||
res.overwrites = overwrites
|
||||
|
||||
hash, err := hashPoints(merged)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if found && hash == stored.Hash {
|
||||
// Хеш — детектор изменений: совпал, значит писать нечего. Именно
|
||||
// это делает широкие проходы синхронизации дешёвыми.
|
||||
res.unchanged = true
|
||||
return nil
|
||||
}
|
||||
res.sealed = found && stored.Sealed
|
||||
|
||||
now := Now()
|
||||
b := Bucket{
|
||||
Metric: key.metric,
|
||||
Layer: key.layer,
|
||||
HourUTC: key.hourUTC,
|
||||
Units: firstNonEmpty(group.units, stored.Units),
|
||||
Points: merged,
|
||||
Hash: hash,
|
||||
Sealed: stored.Sealed,
|
||||
FirstTS: merged[0].Start,
|
||||
LastTS: merged[len(merged)-1].Start,
|
||||
Delivery: firstNonEmpty(stored.Delivery, deliveryID),
|
||||
}
|
||||
return writeBucket(ctx, tx, b, now)
|
||||
})
|
||||
stored, found, err := readBucket(ctx, tx, key)
|
||||
if err != nil {
|
||||
return res, err
|
||||
}
|
||||
|
||||
merged, overwrites := mergePoints(stored.Points, group.points)
|
||||
res.overwrites = overwrites
|
||||
// Считаем сохранённые точки, а не присланные: точные повторы внутри
|
||||
// доставки схлопываются, и счётчик присланных систематически завышал бы
|
||||
// содержимое витрины — расхождение «прислали 1000, лежит 700» было бы
|
||||
// невидимо ровно тогда, когда точки начнут теряться по-настоящему.
|
||||
res.stored = len(merged) - len(stored.Points)
|
||||
res.unitsConflict = stored.Units != "" && group.units != "" && stored.Units != group.units
|
||||
|
||||
hash, err := hashPoints(merged)
|
||||
if err != nil {
|
||||
return res, err
|
||||
}
|
||||
if found && hash == stored.Hash {
|
||||
// Хеш — детектор изменений: совпал, значит писать нечего. Именно это
|
||||
// делает широкие проходы синхронизации дешёвыми.
|
||||
res.unchanged = true
|
||||
return res, nil
|
||||
}
|
||||
res.sealed = found && stored.Sealed
|
||||
|
||||
b := Bucket{
|
||||
Metric: key.metric,
|
||||
Layer: key.layer,
|
||||
HourUTC: key.hourUTC,
|
||||
Units: firstNonEmpty(stored.Units, group.units),
|
||||
Points: merged,
|
||||
Hash: hash,
|
||||
Sealed: stored.Sealed,
|
||||
FirstTS: merged[0].Start,
|
||||
LastTS: merged[len(merged)-1].Start,
|
||||
Delivery: firstNonEmpty(stored.Delivery, deliveryID),
|
||||
}
|
||||
if err := writeBucket(ctx, tx, b, Now()); err != nil {
|
||||
return res, err
|
||||
}
|
||||
return res, nil
|
||||
}
|
||||
|
||||
@@ -196,22 +270,26 @@ func mergePoints(stored, incoming []Point) ([]Point, int) {
|
||||
}
|
||||
|
||||
byCoord := make(map[coord]Point, len(stored)+len(incoming))
|
||||
order := make([]coord, 0, len(stored)+len(incoming))
|
||||
|
||||
put := func(p Point) int {
|
||||
c := coord{start: p.Start.UnixNano(), end: p.End.UnixNano()}
|
||||
old, ok := byCoord[c]
|
||||
if !ok {
|
||||
byCoord[c] = p
|
||||
order = append(order, c)
|
||||
return 0
|
||||
}
|
||||
if bytes.Equal(old.Raw, p.Raw) {
|
||||
// Побайтовое равенство — только быстрый путь. Столкновением считается
|
||||
// расхождение КАНОНИЧЕСКИХ форм: канонизация и заведена потому, что
|
||||
// байты нестабильны. Из 81952 повторно приехавших точек 67534
|
||||
// различаются лишь порядком ключей, ещё 63% — последним разрядом
|
||||
// double. Считай мы по байтам, счётчик перезаписей давал бы тысячи
|
||||
// ложных срабатываний на каждом глубоком проходе, и настоящий отказ
|
||||
// правила слияния стал бы неотличим от нормы.
|
||||
if bytes.Equal(old.Raw, p.Raw) || canon.Equal(old.Raw, p.Raw) {
|
||||
return 0
|
||||
}
|
||||
|
||||
winner := resolve(old, p)
|
||||
byCoord[c] = winner
|
||||
byCoord[c] = resolve(old, p)
|
||||
return 1
|
||||
}
|
||||
|
||||
@@ -223,9 +301,13 @@ func mergePoints(stored, incoming []Point) ([]Point, int) {
|
||||
overwrites += put(p)
|
||||
}
|
||||
|
||||
out := make([]Point, 0, len(order))
|
||||
for _, c := range order {
|
||||
out = append(out, byCoord[c])
|
||||
// Порядок точек в объекте канонический и входит в хеш: его задаёт ТОЛЬКО
|
||||
// сортировка ниже. Порядок обхода карты не специфицирован, и полагаться на
|
||||
// него значило бы получать разные хеши для одного содержимого — тогда
|
||||
// «неизменившийся» объект переписывался бы каждым глубоким проходом.
|
||||
out := make([]Point, 0, len(byCoord))
|
||||
for _, p := range byCoord {
|
||||
out = append(out, p)
|
||||
}
|
||||
sort.Slice(out, func(i, j int) bool {
|
||||
if !out[i].Start.Equal(out[j].Start) {
|
||||
@@ -378,14 +460,21 @@ func encodePayload(points []Point) ([]byte, error) {
|
||||
})
|
||||
}
|
||||
|
||||
raw, err := json.Marshal(sp)
|
||||
if err != nil {
|
||||
// Через Encoder с выключенным HTML-экранированием, а не json.Marshal:
|
||||
// Marshal превращает `&`, `<` и `>` внутри содержимого точки в
|
||||
// \u0026, \u003c, \u003e. Порчи значений это не даёт, но обещание
|
||||
// «точка хранится дословно» перестаёт быть правдой, а сравнение байтов
|
||||
// при следующей доставке той же точки начинает промахиваться навсегда.
|
||||
var raw bytes.Buffer
|
||||
enc := json.NewEncoder(&raw)
|
||||
enc.SetEscapeHTML(false)
|
||||
if err := enc.Encode(sp); err != nil {
|
||||
return nil, fmt.Errorf("сериализация точек: %w", err)
|
||||
}
|
||||
|
||||
var buf bytes.Buffer
|
||||
gz := gzip.NewWriter(&buf)
|
||||
if _, err := gz.Write(raw); err != nil {
|
||||
if _, err := gz.Write(raw.Bytes()); err != nil {
|
||||
return nil, fmt.Errorf("сжатие точек: %w", err)
|
||||
}
|
||||
if err := gz.Close(); err != nil {
|
||||
|
||||
Reference in New Issue
Block a user