полнота точки — множество ключей, победитель — функция множества точек
- отношение победы было нетранзитивным: полнота (частичный порядок) плюс тай-брейк (тотальный) в попарной свёртке давали цикл, из-за которого одна и та же доставка меняла содержимое объекта при каждой пересборке - надмножество побеждает только при совпадении значений общих содержательных ключей: иначе точка без единого измерения вытесняла измерение - Less стал тотальным, isEmpty не материализует значение, имя метрики в координате столкновения обрезается, отпечаток витрины включает units и sealed - на живом архиве строгий no-op: 1737 объектов, содержимое совпало побайтово
This commit is contained in:
+207
-44
@@ -4,7 +4,9 @@ import (
|
||||
"bytes"
|
||||
"compress/gzip"
|
||||
"context"
|
||||
"crypto/sha256"
|
||||
"database/sql"
|
||||
"encoding/hex"
|
||||
"encoding/json"
|
||||
"errors"
|
||||
"fmt"
|
||||
@@ -58,13 +60,23 @@ type MergeStats struct {
|
||||
// сохранённых. Молчаливая замена недопустима: внутри точки единиц нет, и
|
||||
// у ранних точек не остаётся ничего, по чему их единицы восстановимы.
|
||||
UnitsConflicts int
|
||||
// Incomparable — столкновения, где наборы полей несравнимы: у каждой точки
|
||||
// есть содержательный ключ, которого нет у другой. Правило полноты тут
|
||||
// бессильно, и вместо объединения полей — которого на живом потоке не
|
||||
// потребовалось ни разу — заведено наблюдение. Несравнимость считается
|
||||
// СВЕРХ Overwrites, а не вместо: иначе сумма перезаписей за период
|
||||
// перестала бы быть сравнимой с прежней.
|
||||
Incomparable int
|
||||
// Collisions — координаты первых столкновений, для записи в лог. Без них
|
||||
// счётчик перезаписей не говорит, какая метрика и какой час пострадали.
|
||||
Collisions []Collision
|
||||
// IncomparableAt — то же для несравнимых наборов.
|
||||
IncomparableAt []Collision
|
||||
}
|
||||
|
||||
// Collision — координаты объекта, где содержимое точки было перезаписано.
|
||||
// Значений точек не несёт: данные о здоровье чувствительнее токенов.
|
||||
// Collision — координаты объекта, где столкновение разрешилось перезаписью
|
||||
// содержимого точки. Значений точек не несёт: данные о здоровье чувствительнее
|
||||
// токенов.
|
||||
type Collision struct {
|
||||
Metric string
|
||||
Layer string
|
||||
@@ -75,6 +87,21 @@ type Collision struct {
|
||||
// Больше горсти не нужно: они нужны как зацепка для разбора, а не как отчёт.
|
||||
const maxCollisionsReported = 5
|
||||
|
||||
// maxMetricInLog — предел длины имени метрики в координате столкновения.
|
||||
//
|
||||
// Имя приходит из тела доставки дословно и ничем не ограничено, а предел
|
||||
// приёма — 64 МиБ: без обрезки одна доставка порождает WARN-строку в десятки
|
||||
// мегабайт и вытесняет из ротации логов всю недавнюю историю, включая записи о
|
||||
// доставках, которые действительно потерялись. Имена метрик HAE — десятки байт.
|
||||
const maxMetricInLog = 64
|
||||
|
||||
func clipMetric(metric string) string {
|
||||
if len(metric) <= maxMetricInLog {
|
||||
return metric
|
||||
}
|
||||
return metric[:maxMetricInLog] + "…"
|
||||
}
|
||||
|
||||
// MergePoints раскладывает точки по часовым объектам и сливает их с
|
||||
// сохранёнными.
|
||||
//
|
||||
@@ -110,6 +137,7 @@ func (s *Store) MergePoints(ctx context.Context, in []IncomingPoint, deliveryID
|
||||
stats.Buckets++
|
||||
stats.Stored += res.stored
|
||||
stats.Overwrites += res.overwrites
|
||||
stats.Incomparable += res.incomparable
|
||||
if res.unchanged {
|
||||
stats.Unchanged++
|
||||
}
|
||||
@@ -119,10 +147,15 @@ func (s *Store) MergePoints(ctx context.Context, in []IncomingPoint, deliveryID
|
||||
if res.unitsConflict {
|
||||
stats.UnitsConflicts++
|
||||
}
|
||||
// Список координат упирается в потолок, счётчики — нет: обрезанный
|
||||
// список остаётся зацепкой для разбора, а масштаб события считает
|
||||
// счётчик.
|
||||
coord := Collision{Metric: clipMetric(key.metric), Layer: key.layer, HourUTC: key.hourUTC}
|
||||
if res.overwrites > 0 && len(stats.Collisions) < maxCollisionsReported {
|
||||
stats.Collisions = append(stats.Collisions, Collision{
|
||||
Metric: key.metric, Layer: key.layer, HourUTC: key.hourUTC,
|
||||
})
|
||||
stats.Collisions = append(stats.Collisions, coord)
|
||||
}
|
||||
if res.incomparable > 0 && len(stats.IncomparableAt) < maxCollisionsReported {
|
||||
stats.IncomparableAt = append(stats.IncomparableAt, coord)
|
||||
}
|
||||
}
|
||||
return nil
|
||||
@@ -192,6 +225,7 @@ func groupByHour(in []IncomingPoint) map[bucketKey]*pointGroup {
|
||||
|
||||
type mergeResult struct {
|
||||
overwrites int
|
||||
incomparable int
|
||||
stored int
|
||||
unchanged bool
|
||||
sealed bool
|
||||
@@ -211,8 +245,9 @@ func mergeBucket(ctx context.Context, tx *sql.Tx, key bucketKey, group *pointGro
|
||||
return res, err
|
||||
}
|
||||
|
||||
merged, overwrites := mergePoints(stored.Points, group.points)
|
||||
merged, overwrites, incomparable := mergePoints(stored.Points, group.points)
|
||||
res.overwrites = overwrites
|
||||
res.incomparable = incomparable
|
||||
// Считаем сохранённые точки, а не присланные: точные повторы внутри
|
||||
// доставки схлопываются, и счётчик присланных систематически завышал бы
|
||||
// содержимое витрины — расхождение «прислали 1000, лежит 700» было бы
|
||||
@@ -253,85 +288,169 @@ func mergeBucket(ctx context.Context, tx *sql.Tx, key bucketKey, group *pointGro
|
||||
// mergePoints сливает сохранённые точки с пришедшими по координатному ключу.
|
||||
//
|
||||
// При столкновении выигрывает БОЛЕЕ ПОЛНАЯ точка, а не последняя пришедшая:
|
||||
// 0.66% координат различаются набором полей при одинаковом значении, и правило
|
||||
// «последняя победила» стирало бы у сохранённой точки поля, которых новая не
|
||||
// несёт.
|
||||
// 981 столкновение из 2 897 различается набором полей, и правило «последняя
|
||||
// победила» стирало бы у сохранённой точки поля, которых новая не несёт.
|
||||
//
|
||||
// При равной полноте исход определяется порядком канонических форм, а не
|
||||
// порядком доставок: у сохранённой точки нет провенанса, а четверть доставок
|
||||
// несёт столкновения внутри себя, где время приёма общее. Свёртка по журналу
|
||||
// обязана давать то же состояние, что приём в реальном времени.
|
||||
//
|
||||
// Второй счётчик — несравнимые наборы полей. Они и есть та часть правила,
|
||||
// которую заменили наблюдением: объединять поля никто не будет, пока счётчик
|
||||
// не заговорит.
|
||||
//
|
||||
// Точки из объекта не удаляются никогда.
|
||||
func mergePoints(stored, incoming []Point) ([]Point, int) {
|
||||
func mergePoints(stored, incoming []Point) (merged []Point, overwrites, incomparable int) {
|
||||
type coord struct {
|
||||
start int64
|
||||
end int64
|
||||
}
|
||||
|
||||
byCoord := make(map[coord]Point, len(stored)+len(incoming))
|
||||
byCoord := make(map[coord][]candidate, len(stored)+len(incoming))
|
||||
order := make([]coord, 0, len(stored)+len(incoming))
|
||||
|
||||
put := func(p Point) int {
|
||||
// Кандидаты копятся, а не сворачиваются попарно. Попарная свёртка была
|
||||
// НЕВЕРНА: полнота — частичный порядок, тай-брейк — тотальный, и их
|
||||
// смешение даёт нетранзитивное отношение победы. Оно образует цикл
|
||||
// (A ⊃ B по ключам, B бьёт C тай-брейком, C бьёт A тай-брейком), после
|
||||
// чего исход зависит от того, что уже лежало в объекте: одна и та же
|
||||
// доставка, свёрнутая дважды, давала два разных состояния витрины
|
||||
// поочерёдно. Это ломало главный инвариант — «состояние пересобираемо».
|
||||
add := func(p Point) {
|
||||
c := coord{start: p.Start.UnixNano(), end: p.End.UnixNano()}
|
||||
old, ok := byCoord[c]
|
||||
if !ok {
|
||||
byCoord[c] = p
|
||||
return 0
|
||||
cands, seen := byCoord[c]
|
||||
if !seen {
|
||||
order = append(order, c)
|
||||
}
|
||||
// Побайтовое равенство — только быстрый путь. Столкновением считается
|
||||
// расхождение КАНОНИЧЕСКИХ форм: канонизация и заведена потому, что
|
||||
cand := newCandidate(p)
|
||||
// Побайтовое равенство — только быстрый путь. Тем же самым считается
|
||||
// совпадение КАНОНИЧЕСКИХ форм: канонизация и заведена потому, что
|
||||
// байты нестабильны. Из 81952 повторно приехавших точек 67534
|
||||
// различаются лишь порядком ключей, ещё 63% — последним разрядом
|
||||
// double. Считай мы по байтам, счётчик перезаписей давал бы тысячи
|
||||
// ложных срабатываний на каждом глубоком проходе, и настоящий отказ
|
||||
// правила слияния стал бы неотличим от нормы.
|
||||
if bytes.Equal(old.Raw, p.Raw) || canon.Equal(old.Raw, p.Raw) {
|
||||
return 0
|
||||
for _, q := range cands {
|
||||
if bytes.Equal(q.key, cand.key) {
|
||||
return
|
||||
}
|
||||
}
|
||||
|
||||
byCoord[c] = resolve(old, p)
|
||||
return 1
|
||||
byCoord[c] = append(cands, cand)
|
||||
}
|
||||
|
||||
overwrites := 0
|
||||
for _, p := range stored {
|
||||
put(p)
|
||||
add(p)
|
||||
}
|
||||
for _, p := range incoming {
|
||||
overwrites += put(p)
|
||||
add(p)
|
||||
}
|
||||
|
||||
out := make([]Point, 0, len(order))
|
||||
for _, c := range order {
|
||||
cands := byCoord[c]
|
||||
winner, unrelated := resolve(cands)
|
||||
// Перезаписей столько, сколько точек уступило: при двух кандидатах
|
||||
// одна, при трёх две. Так счёт остаётся сравнимым с прежним, где
|
||||
// столкновение считалось на каждую приехавшую точку.
|
||||
overwrites += len(cands) - 1
|
||||
if unrelated {
|
||||
incomparable++
|
||||
}
|
||||
out = append(out, winner)
|
||||
}
|
||||
|
||||
// Порядок точек в объекте канонический и входит в хеш: его задаёт ТОЛЬКО
|
||||
// сортировка ниже. Порядок обхода карты не специфицирован, и полагаться на
|
||||
// него значило бы получать разные хеши для одного содержимого — тогда
|
||||
// «неизменившийся» объект переписывался бы каждым глубоким проходом.
|
||||
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) {
|
||||
return out[i].Start.Before(out[j].Start)
|
||||
}
|
||||
return out[i].End.Before(out[j].End)
|
||||
})
|
||||
return out, overwrites
|
||||
return out, overwrites, incomparable
|
||||
}
|
||||
|
||||
// resolve выбирает победителя столкновения: сперва по полноте, затем
|
||||
// детерминированно по канонической форме.
|
||||
func resolve(a, b Point) Point {
|
||||
ca, cb := canon.Completeness(a.Raw), canon.Completeness(b.Raw)
|
||||
switch {
|
||||
case ca > cb:
|
||||
return a
|
||||
case cb > ca:
|
||||
return b
|
||||
case canon.Less(a.Raw, b.Raw):
|
||||
return a
|
||||
default:
|
||||
return b
|
||||
// candidate — точка вместе с тем, что о ней нужно знать при выборе
|
||||
// победителя. Разбор и канонизация делаются ОДИН раз на точку: сравнений
|
||||
// квадратично по числу кандидатов, и пересчёт на каждое сравнение означал бы
|
||||
// разбор точки столько раз, сколько на координате кандидатов.
|
||||
type candidate struct {
|
||||
pt Point
|
||||
key []byte // каноническая форма: она же ключ дедупликации и порядок
|
||||
fields canon.Fields
|
||||
}
|
||||
|
||||
func newCandidate(p Point) candidate {
|
||||
return candidate{pt: p, key: canon.SortKey(p.Raw), fields: canon.Analyze(p.Raw)}
|
||||
}
|
||||
|
||||
// resolve выбирает победителя среди кандидатов одной координаты.
|
||||
//
|
||||
// Победитель — функция МНОЖЕСТВА кандидатов, а не порядка их поступления.
|
||||
// Сперва отбрасываются те, кого превосходит по полноте кто-то другой
|
||||
// (полнота — частичный порядок, поэтому «непревзойдённые» определены
|
||||
// однозначно), затем среди оставшихся берётся минимум по каноническому
|
||||
// порядку — он тотальный, поэтому минимум единственен. Обе операции зависят
|
||||
// только от состава множества, поэтому пересборка журнала даёт то же
|
||||
// состояние, что живой приём, а повторная свёртка той же доставки не меняет
|
||||
// ничего.
|
||||
//
|
||||
// Победителем остаётся одна из пришедших точек ДОСЛОВНО: правило выбирает, а
|
||||
// не конструирует. Каноническая форма существует только в момент сравнения, и
|
||||
// вернуть её значило бы сохранить округлённое число вместо присланного.
|
||||
//
|
||||
// Второй возврат — остались ли непревзойдёнными несколько точек с
|
||||
// несравнимыми наборами содержательных полей. На живом потоке этого не
|
||||
// случилось ни разу (0 из 2 897 столкновений), поэтому объединение полей не
|
||||
// реализовано: вместо него счётчик, который скажет, если событие наступит.
|
||||
func resolve(cands []candidate) (Point, bool) {
|
||||
if len(cands) == 1 {
|
||||
return cands[0].pt, false
|
||||
}
|
||||
|
||||
maximal := make([]candidate, 0, len(cands))
|
||||
for i, a := range cands {
|
||||
dominated := false
|
||||
for j, b := range cands {
|
||||
if i == j {
|
||||
continue
|
||||
}
|
||||
if b.fields.Relate(a.fields) == canon.FullnessSuperset {
|
||||
dominated = true
|
||||
break
|
||||
}
|
||||
}
|
||||
if !dominated {
|
||||
maximal = append(maximal, a)
|
||||
}
|
||||
}
|
||||
|
||||
best := maximal[0]
|
||||
for _, c := range maximal[1:] {
|
||||
if bytes.Compare(c.key, best.key) < 0 {
|
||||
best = c
|
||||
}
|
||||
}
|
||||
|
||||
// Несравнимость — не «осталось больше одного»: точки с одинаковыми
|
||||
// наборами полей и разными значениями тоже остаются обе, и это рядовой
|
||||
// тай-брейк. Считается только то, ради чего отложено объединение полей:
|
||||
// у каждой из двух есть содержательный ключ, которого нет у другой.
|
||||
return best.pt, hasIncomparablePair(maximal)
|
||||
}
|
||||
|
||||
func hasIncomparablePair(cands []candidate) bool {
|
||||
for i := range cands {
|
||||
for j := i + 1; j < len(cands); j++ {
|
||||
if cands[i].fields.Relate(cands[j].fields) == canon.FullnessIncomparable {
|
||||
return true
|
||||
}
|
||||
}
|
||||
}
|
||||
return false
|
||||
}
|
||||
|
||||
func hashPoints(points []Point) (string, error) {
|
||||
@@ -580,6 +699,50 @@ func (s *Store) CountBuckets(ctx context.Context) (int64, error) {
|
||||
return n, nil
|
||||
}
|
||||
|
||||
// Fingerprint возвращает отпечаток содержимого витрины: SHA-256 по координатам
|
||||
// и хешам всех объектов в детерминированном порядке.
|
||||
//
|
||||
// Нужен проверке сходимости на живом архиве. Число объектов и число точек к
|
||||
// правилу разрешения столкновений нечувствительны: на координате всегда лежит
|
||||
// ровно одна точка, и правило выбирает, КАКАЯ это будет точка, а не сколько их.
|
||||
// Значит «объектов столько же» совпадёт и при заведомо сломанном правиле, а
|
||||
// отпечаток — нет.
|
||||
//
|
||||
// Значений точек он не раскрывает: содержимое участвует только своим хешем.
|
||||
func (s *Store) Fingerprint(ctx context.Context) (string, error) {
|
||||
const q = `
|
||||
SELECT metric, layer, hour_utc, content_hash, points, units, sealed FROM bucket
|
||||
ORDER BY metric, layer, hour_utc`
|
||||
|
||||
rows, err := s.db.QueryContext(ctx, q)
|
||||
if err != nil {
|
||||
return "", fmt.Errorf("select buckets: %w", err)
|
||||
}
|
||||
defer func() { _ = rows.Close() }()
|
||||
|
||||
h := sha256.New()
|
||||
for rows.Next() {
|
||||
var metric, layer, hour, hash, units string
|
||||
var points int
|
||||
var sealed bool
|
||||
if err := rows.Scan(&metric, &layer, &hour, &hash, &points, &units, &sealed); err != nil {
|
||||
return "", fmt.Errorf("scan bucket: %w", err)
|
||||
}
|
||||
// Поля переменной длины идут с длиной впереди: разделитель, который
|
||||
// может встретиться ВНУТРИ поля, даёт одну строку для разных состояний,
|
||||
// а имя метрики и единицы приходят из тела доставки дословно. Ошибиться
|
||||
// здесь значит получить «состояние совпало» при разошедшемся состоянии —
|
||||
// то есть сломать молча ровно тот оракул, ради которого отпечаток и
|
||||
// заведён. Тот же приём в canon.HashAll и по той же причине.
|
||||
fmt.Fprintf(h, "%d:%s|%d:%s|%s|%s|%d|%d:%s|%t\n",
|
||||
len(metric), metric, len(layer), layer, hour, hash, points, len(units), units, sealed)
|
||||
}
|
||||
if err := rows.Err(); err != nil {
|
||||
return "", fmt.Errorf("select buckets: %w", err)
|
||||
}
|
||||
return hex.EncodeToString(h.Sum(nil)), nil
|
||||
}
|
||||
|
||||
// Bucket читает объект по координатам. Нужен тестам и будущему Read API.
|
||||
func (s *Store) Bucket(ctx context.Context, metric, layer string, hour time.Time) (Bucket, error) {
|
||||
tx, err := s.db.BeginTx(ctx, &sql.TxOptions{ReadOnly: true})
|
||||
|
||||
@@ -4,6 +4,7 @@ import (
|
||||
"context"
|
||||
"encoding/json"
|
||||
"errors"
|
||||
"fmt"
|
||||
"path/filepath"
|
||||
"strings"
|
||||
"sync"
|
||||
@@ -150,6 +151,12 @@ func TestMergePointsПовторНеПишет(t *testing.T) {
|
||||
if stats.Unchanged != 1 {
|
||||
t.Errorf("объектов без изменений %d, ожидался 1", stats.Unchanged)
|
||||
}
|
||||
// Повтор — не столкновение: точка сравнивается сама с собой, и ни один
|
||||
// счётчик правила слияния расти не должен.
|
||||
if stats.Overwrites != 0 || stats.Incomparable != 0 {
|
||||
t.Errorf("повтор посчитан столкновением: перезаписей %d, несравнимых %d",
|
||||
stats.Overwrites, stats.Incomparable)
|
||||
}
|
||||
|
||||
after, err := st.Bucket(ctx, "step_count", "minute", ts(t, "2025-06-05T10:00:00Z"))
|
||||
if err != nil {
|
||||
@@ -301,6 +308,149 @@ func TestMergePointsБеднаяТочкаНеСтираетБогатую(t *te
|
||||
}
|
||||
}
|
||||
|
||||
// Полнота — множество ключей, а не их число. Счётчик значащих полей давал
|
||||
// сохранённой точке 5 против 2 и стирал настоящее измерение безвозвратно:
|
||||
// восстановить его можно было бы только из сырого архива, пока он жив.
|
||||
func TestMergePointsПоляБезСодержанияНеСтираютИзмерение(t *testing.T) {
|
||||
t.Parallel()
|
||||
|
||||
st := open(t)
|
||||
ctx := context.Background()
|
||||
|
||||
hollow := point(t, "step_count", "minute", "2025-06-05T10:00:00Z", "2025-06-05T10:00:00Z",
|
||||
`{"qty":0,"a":0,"b":0,"c":{},"d":[]}`)
|
||||
measured := point(t, "step_count", "minute", "2025-06-05T10:00:00Z", "2025-06-05T10:00:00Z",
|
||||
`{"date":"2026-07-31 12:00:00 +0300","qty":123.4}`)
|
||||
|
||||
if _, err := st.MergePoints(ctx, []store.IncomingPoint{hollow}, "d1"); err != nil {
|
||||
t.Fatalf("первое слияние: %v", err)
|
||||
}
|
||||
stats, err := st.MergePoints(ctx, []store.IncomingPoint{measured}, "d2")
|
||||
if err != nil {
|
||||
t.Fatalf("второе слияние: %v", err)
|
||||
}
|
||||
|
||||
b, err := st.Bucket(ctx, "step_count", "minute", ts(t, "2025-06-05T10:00:00Z"))
|
||||
if err != nil {
|
||||
t.Fatalf("чтение: %v", err)
|
||||
}
|
||||
if got := string(b.Points[0].Raw); got != string(measured.Raw) {
|
||||
t.Errorf("измерение стёрто точкой без содержания: %s", got)
|
||||
}
|
||||
if stats.Incomparable != 0 {
|
||||
t.Errorf("несравнимых %d: наборы сравнимы, содержательных ключей у первой нет",
|
||||
stats.Incomparable)
|
||||
}
|
||||
}
|
||||
|
||||
// Поле с нулевым значением содержания не несёт, но и теряться не должно: при
|
||||
// равном множестве содержательных ключей выигрывает точка со всеми ключами.
|
||||
func TestMergePointsРавноеСодержаниеНеТеряетПоля(t *testing.T) {
|
||||
t.Parallel()
|
||||
|
||||
st := open(t)
|
||||
ctx := context.Background()
|
||||
|
||||
wide := point(t, "heart_rate", "minute", "2025-06-05T10:00:00Z", "2025-06-05T10:00:00Z",
|
||||
`{"date":"d","qty":10,"Min":0,"Max":0}`)
|
||||
narrow := point(t, "heart_rate", "minute", "2025-06-05T10:00:00Z", "2025-06-05T10:00:00Z",
|
||||
`{"date":"d","qty":12}`)
|
||||
|
||||
if _, err := st.MergePoints(ctx, []store.IncomingPoint{wide}, "d1"); err != nil {
|
||||
t.Fatalf("первое слияние: %v", err)
|
||||
}
|
||||
if _, err := st.MergePoints(ctx, []store.IncomingPoint{narrow}, "d2"); err != nil {
|
||||
t.Fatalf("второе слияние: %v", err)
|
||||
}
|
||||
|
||||
b, err := st.Bucket(ctx, "heart_rate", "minute", ts(t, "2025-06-05T10:00:00Z"))
|
||||
if err != nil {
|
||||
t.Fatalf("чтение: %v", err)
|
||||
}
|
||||
if got := string(b.Points[0].Raw); got != string(wide.Raw) {
|
||||
t.Errorf("ключи Min и Max потеряны: %s", got)
|
||||
}
|
||||
}
|
||||
|
||||
// Несравнимые наборы полей на живом потоке не встретились ни разу (0 из 2 897
|
||||
// столкновений), поэтому объединение полей не реализовано. Взамен — наблюдение:
|
||||
// счётчик и координаты объекта, по которым событие можно будет разобрать.
|
||||
func TestMergePointsНесравнимыеНаборыСчитаются(t *testing.T) {
|
||||
t.Parallel()
|
||||
|
||||
st := open(t)
|
||||
ctx := context.Background()
|
||||
|
||||
a := point(t, "blood_glucose", "minute", "2025-06-05T10:00:00Z", "2025-06-05T10:00:00Z",
|
||||
`{"qty":5.1}`)
|
||||
b := point(t, "blood_glucose", "minute", "2025-06-05T10:00:00Z", "2025-06-05T10:00:00Z",
|
||||
`{"mealTime":"До еды"}`)
|
||||
|
||||
if _, err := st.MergePoints(ctx, []store.IncomingPoint{a}, "d1"); err != nil {
|
||||
t.Fatalf("первое слияние: %v", err)
|
||||
}
|
||||
stats, err := st.MergePoints(ctx, []store.IncomingPoint{b}, "d2")
|
||||
if err != nil {
|
||||
t.Fatalf("второе слияние: %v", err)
|
||||
}
|
||||
|
||||
if stats.Incomparable != 1 {
|
||||
t.Fatalf("несравнимых %d, ожидался 1", stats.Incomparable)
|
||||
}
|
||||
// Несравнимость — частный случай столкновения: иначе сумма перезаписей за
|
||||
// период перестала бы быть сравнимой с прежней.
|
||||
if stats.Overwrites != 1 {
|
||||
t.Errorf("перезаписей %d, ожидалась 1", stats.Overwrites)
|
||||
}
|
||||
if len(stats.IncomparableAt) != 1 {
|
||||
t.Fatalf("координат %d, ожидалась 1", len(stats.IncomparableAt))
|
||||
}
|
||||
if got := stats.IncomparableAt[0]; got.Metric != "blood_glucose" || got.Layer != "minute" {
|
||||
t.Errorf("координаты объекта не те: %s/%s", got.Metric, got.Layer)
|
||||
}
|
||||
|
||||
got, err := st.Bucket(ctx, "blood_glucose", "minute", ts(t, "2025-06-05T10:00:00Z"))
|
||||
if err != nil {
|
||||
t.Fatalf("чтение: %v", err)
|
||||
}
|
||||
if len(got.Points) != 1 {
|
||||
t.Errorf("точек %d, ожидалась 1: правило обязано выбрать одну", len(got.Points))
|
||||
}
|
||||
}
|
||||
|
||||
// Список координат упирается в потолок, счётчик — нет: обрезанный список
|
||||
// остаётся зацепкой для разбора, а масштаб события считает счётчик.
|
||||
func TestMergePointsСчётчикРастётПослеПотолкаКоординат(t *testing.T) {
|
||||
t.Parallel()
|
||||
|
||||
st := open(t)
|
||||
ctx := context.Background()
|
||||
|
||||
const hours = 8
|
||||
var first, second []store.IncomingPoint
|
||||
for h := range hours {
|
||||
at := fmt.Sprintf("2025-06-05T%02d:00:00Z", h)
|
||||
first = append(first, point(t, "blood_glucose", "minute", at, at, `{"qty":5.1}`))
|
||||
second = append(second, point(t, "blood_glucose", "minute", at, at, `{"mealTime":"До еды"}`))
|
||||
}
|
||||
|
||||
if _, err := st.MergePoints(ctx, first, "d1"); err != nil {
|
||||
t.Fatalf("первое слияние: %v", err)
|
||||
}
|
||||
stats, err := st.MergePoints(ctx, second, "d2")
|
||||
if err != nil {
|
||||
t.Fatalf("второе слияние: %v", err)
|
||||
}
|
||||
|
||||
if stats.Incomparable != hours {
|
||||
t.Errorf("несравнимых %d, ожидалось %d: счётчик остановился вместе со списком",
|
||||
stats.Incomparable, hours)
|
||||
}
|
||||
if len(stats.IncomparableAt) >= hours {
|
||||
t.Errorf("координат %d — список не обрезан потолком", len(stats.IncomparableAt))
|
||||
}
|
||||
}
|
||||
|
||||
// source нестабилен: то же измерение приезжает то с одним именем устройства,
|
||||
// то с другим. Он не входит в ключ и не считается полнотой.
|
||||
func TestMergePointsСменаИсточникаНеСоздаётВторуюТочку(t *testing.T) {
|
||||
@@ -529,3 +679,170 @@ func TestMergePointsОтменаНеОставляетПоловины(t *testin
|
||||
t.Errorf("точек %d, ожидалась 1: отмена оставила половинчатое состояние", len(b.Points))
|
||||
}
|
||||
}
|
||||
|
||||
// Отношение победы обязано быть функцией МНОЖЕСТВА точек, а не порядка их
|
||||
// поступления. Попарная свёртка этого не давала: полнота — частичный порядок,
|
||||
// тай-брейк — тотальный, и вместе они образовывали цикл (A ⊃ B по ключам,
|
||||
// B бьёт C тай-брейком, C бьёт A тай-брейком). Из-за цикла одна и та же
|
||||
// доставка, свёрнутая дважды, давала два состояния витрины поочерёдно —
|
||||
// хранилище переставало быть свёрткой журнала.
|
||||
//
|
||||
// Тройка ниже — ровно такая: её нашёл враждебный проход ревью.
|
||||
const (
|
||||
cyclеB = `{"a":1,"b":1}`
|
||||
cyclеC = `{"a":2,"d":1}`
|
||||
cyclеA = `{"a":3,"b":1,"c":1}`
|
||||
)
|
||||
|
||||
func cycleTriple(t *testing.T) []store.IncomingPoint {
|
||||
t.Helper()
|
||||
|
||||
return []store.IncomingPoint{
|
||||
point(t, "heart_rate", "raw", "2025-06-05T10:00:00Z", "2025-06-05T10:00:00Z", cyclеB),
|
||||
point(t, "heart_rate", "raw", "2025-06-05T10:00:00Z", "2025-06-05T10:00:00Z", cyclеC),
|
||||
point(t, "heart_rate", "raw", "2025-06-05T10:00:00Z", "2025-06-05T10:00:00Z", cyclеA),
|
||||
}
|
||||
}
|
||||
|
||||
func TestMergePointsПовторнаяСвёрткаНеМеняетСостояние(t *testing.T) {
|
||||
t.Parallel()
|
||||
|
||||
st := open(t)
|
||||
ctx := context.Background()
|
||||
in := cycleTriple(t)
|
||||
|
||||
state := func() (string, string) {
|
||||
t.Helper()
|
||||
|
||||
if _, err := st.MergePoints(ctx, in, "d1"); err != nil {
|
||||
t.Fatalf("слияние: %v", err)
|
||||
}
|
||||
b, err := st.Bucket(ctx, "heart_rate", "raw", ts(t, "2025-06-05T10:00:00Z"))
|
||||
if err != nil {
|
||||
t.Fatalf("чтение: %v", err)
|
||||
}
|
||||
fp, err := st.Fingerprint(ctx)
|
||||
if err != nil {
|
||||
t.Fatalf("отпечаток: %v", err)
|
||||
}
|
||||
return string(b.Points[0].Raw), fp
|
||||
}
|
||||
|
||||
wantRaw, wantFP := state()
|
||||
for pass := 2; pass <= 4; pass++ {
|
||||
gotRaw, gotFP := state()
|
||||
if gotRaw != wantRaw || gotFP != wantFP {
|
||||
t.Fatalf("свёртка %d той же доставки изменила витрину:\n было %s / %s\n стало %s / %s",
|
||||
pass, wantRaw, wantFP[:16], gotRaw, gotFP[:16])
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestMergePointsИсходНеЗависитОтПерестановки(t *testing.T) {
|
||||
t.Parallel()
|
||||
|
||||
ctx := context.Background()
|
||||
in := cycleTriple(t)
|
||||
|
||||
// Все шесть перестановок тройки, и вдобавок разбиение на разные доставки:
|
||||
// в живом приёме точки приходят порознь, в пересборке — вместе.
|
||||
perms := [][]int{{0, 1, 2}, {0, 2, 1}, {1, 0, 2}, {1, 2, 0}, {2, 0, 1}, {2, 1, 0}}
|
||||
|
||||
winner := func(order []int, split bool) string {
|
||||
st := open(t)
|
||||
if split {
|
||||
for _, i := range order {
|
||||
if _, err := st.MergePoints(ctx, []store.IncomingPoint{in[i]}, "d"); err != nil {
|
||||
t.Fatalf("слияние: %v", err)
|
||||
}
|
||||
}
|
||||
} else {
|
||||
batch := make([]store.IncomingPoint, 0, len(order))
|
||||
for _, i := range order {
|
||||
batch = append(batch, in[i])
|
||||
}
|
||||
if _, err := st.MergePoints(ctx, batch, "d"); err != nil {
|
||||
t.Fatalf("слияние: %v", err)
|
||||
}
|
||||
}
|
||||
b, err := st.Bucket(ctx, "heart_rate", "raw", ts(t, "2025-06-05T10:00:00Z"))
|
||||
if err != nil {
|
||||
t.Fatalf("чтение: %v", err)
|
||||
}
|
||||
return string(b.Points[0].Raw)
|
||||
}
|
||||
|
||||
want := winner(perms[0], false)
|
||||
for _, p := range perms {
|
||||
for _, split := range []bool{false, true} {
|
||||
if got := winner(p, split); got != want {
|
||||
t.Errorf("перестановка %v (порознь=%v) дала %s, ожидалось %s", p, split, got, want)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Точка, ни одно значение которой не несёт измерения, не должна вытеснять
|
||||
// настоящее измерение. Раньше вытесняла: множества содержательных ключей
|
||||
// равны, и решал второй разряд — по ключам, а не по содержанию.
|
||||
func TestMergePointsПадингНеВытесняетИзмерение(t *testing.T) {
|
||||
t.Parallel()
|
||||
|
||||
ctx := context.Background()
|
||||
const real = `{"date":"d","qty":72.5}`
|
||||
|
||||
cases := []struct {
|
||||
name string
|
||||
junk string
|
||||
}{
|
||||
{"падинг из null", `{"date":"d","qty":0.001,"p1":null,"p2":null,"p3":null}`},
|
||||
{"падинг из false", `{"date":"d","qty":false,"Min":false,"Max":false}`},
|
||||
}
|
||||
|
||||
for _, c := range cases {
|
||||
t.Run(c.name, func(t *testing.T) {
|
||||
t.Parallel()
|
||||
|
||||
st := open(t)
|
||||
in := []store.IncomingPoint{
|
||||
point(t, "heart_rate", "raw", "2025-06-05T10:00:00Z", "2025-06-05T10:00:00Z", real),
|
||||
point(t, "heart_rate", "raw", "2025-06-05T10:00:00Z", "2025-06-05T10:00:00Z", c.junk),
|
||||
}
|
||||
stats, err := st.MergePoints(ctx, in, "d1")
|
||||
if err != nil {
|
||||
t.Fatalf("слияние: %v", err)
|
||||
}
|
||||
// Правило полноты обязано молчать: это столкновение равнополных,
|
||||
// а не победа надмножества.
|
||||
if stats.Incomparable != 0 {
|
||||
t.Errorf("несравнимых %d, ожидалось 0: наборы содержательных ключей равны", stats.Incomparable)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
// Имя метрики приходит из тела доставки дословно и ничем не ограничено.
|
||||
// Без обрезки одна доставка порождает WARN-строку в десятки мегабайт и
|
||||
// вытесняет из ротации логов всю недавнюю историю.
|
||||
func TestMergePointsИмяМетрикиВКоординатеОбрезано(t *testing.T) {
|
||||
t.Parallel()
|
||||
|
||||
st := open(t)
|
||||
ctx := context.Background()
|
||||
|
||||
huge := strings.Repeat("м", 5000)
|
||||
in := []store.IncomingPoint{
|
||||
point(t, huge, "raw", "2025-06-05T10:00:00Z", "2025-06-05T10:00:00Z", `{"qty":1}`),
|
||||
point(t, huge, "raw", "2025-06-05T10:00:00Z", "2025-06-05T10:00:00Z", `{"qty":2}`),
|
||||
}
|
||||
stats, err := st.MergePoints(ctx, in, "d1")
|
||||
if err != nil {
|
||||
t.Fatalf("слияние: %v", err)
|
||||
}
|
||||
if len(stats.Collisions) == 0 {
|
||||
t.Fatal("столкновение не зафиксировано")
|
||||
}
|
||||
if got := len(stats.Collisions[0].Metric); got > 128 {
|
||||
t.Errorf("имя метрики в координате %d байт — оно уедет в лог как есть", got)
|
||||
}
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user