forked from mtusi2026/mtusi2026lab6
270 lines
10 KiB
Go
270 lines
10 KiB
Go
// Package store, queue.go — брокер Redis Streams для заданий обработки (лаба 5).
|
||
//
|
||
// Почему Redis Streams, а не Pub/Sub: поток хранит сообщения (durable при AOF),
|
||
// consumer group даёт at-least-once доставку и явный ack, XAUTOCLAIM возвращает
|
||
// сообщения упавшего потребителя. В очередь идут только ID (jobs.schema.json).
|
||
//
|
||
// LAB 6: Publish создаёт producer span и инжектирует W3C trace context
|
||
// (traceparent/tracestate) в поля сообщения, чтобы worker продолжил трассу.
|
||
package store
|
||
|
||
import (
|
||
"context"
|
||
"encoding/json"
|
||
"fmt"
|
||
"log/slog"
|
||
"strconv"
|
||
"strings"
|
||
"time"
|
||
|
||
"github.com/redis/go-redis/v9"
|
||
"go.opentelemetry.io/otel"
|
||
"go.opentelemetry.io/otel/attribute"
|
||
"go.opentelemetry.io/otel/propagation"
|
||
"go.opentelemetry.io/otel/trace"
|
||
|
||
"mtusi-messenger/internal/model"
|
||
)
|
||
|
||
const (
|
||
// QueueStreamKey — имя потока заданий.
|
||
QueueStreamKey = "messenger:attachment-jobs"
|
||
// QueueGroup — consumer group worker'ов.
|
||
QueueGroup = "workers"
|
||
// queueMaxLen — приблизительный потолок длины потока (защита от разрастания).
|
||
queueMaxLen = 10000
|
||
)
|
||
|
||
// Queue — обёртка над Redis Streams.
|
||
type Queue struct {
|
||
rdb *redis.Client
|
||
log *slog.Logger
|
||
}
|
||
|
||
// NewQueue — Redis-хук ставится ОДИН РАЗ в main (rdb.AddHook), чтобы не
|
||
// получить дублирующиеся spans на каждой команде.
|
||
func NewQueue(rdb *redis.Client, log *slog.Logger) *Queue {
|
||
return &Queue{rdb: rdb, log: log}
|
||
}
|
||
|
||
// Ensure — идемпотентное создание потока и consumer group.
|
||
func (q *Queue) Ensure(ctx context.Context) error {
|
||
err := q.rdb.XGroupCreateMkStream(ctx, QueueStreamKey, QueueGroup, "0").Err()
|
||
if err != nil && !strings.Contains(err.Error(), "BUSYGROUP") {
|
||
return fmt.Errorf("create consumer group: %w", err)
|
||
}
|
||
return nil
|
||
}
|
||
|
||
// InjectTraceContext сохраняет W3C trace context из ctx в поля сообщения.
|
||
// Вызывается там, где сообщение кладётся в outbox (upload, retry, reaper),
|
||
// чтобы трасса инициатора дожила до момента публикации.
|
||
func InjectTraceContext(ctx context.Context, msg *model.JobMessage) {
|
||
carrier := propagation.MapCarrier{}
|
||
otel.GetTextMapPropagator().Inject(ctx, carrier)
|
||
msg.Traceparent = carrier.Get("traceparent")
|
||
msg.Tracestate = carrier.Get("tracestate")
|
||
}
|
||
|
||
// Publish — добавить сообщение в поток (publisher confirm = успех XADD).
|
||
// LAB 6: восстанавливаем контекст инициатора из полей сообщения, создаём
|
||
// producer span как его дочерний, затем инжектируем СВОЙ контекст для worker.
|
||
func (q *Queue) Publish(ctx context.Context, msg model.JobMessage) (string, error) {
|
||
in := propagation.MapCarrier{}
|
||
if msg.Traceparent != "" {
|
||
in.Set("traceparent", msg.Traceparent)
|
||
}
|
||
if msg.Tracestate != "" {
|
||
in.Set("tracestate", msg.Tracestate)
|
||
}
|
||
ctx = otel.GetTextMapPropagator().Extract(ctx, in)
|
||
|
||
ctx, span := otel.Tracer("messenger-queue").Start(ctx, "queue.publish",
|
||
trace.WithSpanKind(trace.SpanKindProducer),
|
||
trace.WithAttributes(
|
||
attribute.String("messaging.system", "redis_streams"),
|
||
attribute.String("messaging.destination", QueueStreamKey),
|
||
attribute.String("messaging.operation", "publish"),
|
||
attribute.String("job.id", msg.JobID),
|
||
attribute.String("job.type", msg.Type),
|
||
attribute.Int("job.attempt", msg.Attempt),
|
||
),
|
||
)
|
||
defer span.End()
|
||
|
||
out := propagation.MapCarrier{}
|
||
otel.GetTextMapPropagator().Inject(ctx, out)
|
||
msg.Traceparent = out.Get("traceparent")
|
||
msg.Tracestate = out.Get("tracestate")
|
||
|
||
b, err := json.Marshal(msg)
|
||
if err != nil {
|
||
span.RecordError(err)
|
||
return "", fmt.Errorf("marshal job message: %w", err)
|
||
}
|
||
id, err := q.rdb.XAdd(ctx, &redis.XAddArgs{
|
||
Stream: QueueStreamKey,
|
||
MaxLen: queueMaxLen,
|
||
Approx: true,
|
||
Values: map[string]any{"payload": string(b)},
|
||
}).Result()
|
||
if err != nil {
|
||
span.RecordError(err)
|
||
return "", fmt.Errorf("xadd: %w", err)
|
||
}
|
||
span.SetAttributes(attribute.String("messaging.message.id", id))
|
||
return id, nil
|
||
}
|
||
|
||
// Consume — читать новые сообщения группы (BLOCK, COUNT 1: ограниченный prefetch).
|
||
func (q *Queue) Consume(ctx context.Context, consumer string, block time.Duration) ([]redis.XMessage, error) {
|
||
res, err := q.rdb.XReadGroup(ctx, &redis.XReadGroupArgs{
|
||
Group: QueueGroup,
|
||
Consumer: consumer,
|
||
Streams: []string{QueueStreamKey, ">"},
|
||
Count: 1,
|
||
Block: block,
|
||
}).Result()
|
||
if err == redis.Nil {
|
||
return nil, nil
|
||
}
|
||
if err != nil {
|
||
return nil, fmt.Errorf("xreadgroup: %w", err)
|
||
}
|
||
var out []redis.XMessage
|
||
for _, s := range res {
|
||
out = append(out, s.Messages...)
|
||
}
|
||
return out, nil
|
||
}
|
||
|
||
// Ack — подтвердить устойчивую обработку (после COMMIT результата в БД).
|
||
func (q *Queue) Ack(ctx context.Context, msgID string) error {
|
||
return q.rdb.XAck(ctx, QueueStreamKey, QueueGroup, msgID).Err()
|
||
}
|
||
|
||
// ReclaimStale — забрать сообщения, которые держит упавший потребитель.
|
||
// Второе возвращаемое значение XAutoClaim — курсор следующей страницы PEL;
|
||
// игнорируем, т.к. периодический цикл сканирует PEL с "0-0" малыми порциями.
|
||
func (q *Queue) ReclaimStale(ctx context.Context, consumer string, minIdle time.Duration) ([]redis.XMessage, error) {
|
||
msgs, _, err := q.rdb.XAutoClaim(ctx, &redis.XAutoClaimArgs{
|
||
Stream: QueueStreamKey,
|
||
Group: QueueGroup,
|
||
Consumer: consumer,
|
||
MinIdle: minIdle,
|
||
Start: "0-0",
|
||
Count: 4,
|
||
}).Result()
|
||
if err != nil {
|
||
return nil, fmt.Errorf("xautoclaim: %w", err)
|
||
}
|
||
return msgs, nil
|
||
}
|
||
|
||
// QueuePendingStats — глубина и возраст неподтверждённых (не acked) сообщений.
|
||
// XLEN не используем: acked сообщения остаются в потоке до обрезки MAXLEN,
|
||
// поэтому реальная «очередь» — это pending из XPENDING.
|
||
// QueuePendingStats — фактический backlog очереди.
|
||
// Глубина = lag (сообщения, которые группа ещё НЕ прочитала) +
|
||
// pending (прочитанные, но не подтверждённые ack). Ранее считали только
|
||
// pending через XPENDING — это не видело очередь при мёртвом worker'е,
|
||
// потому что сообщения ещё никем не были прочитаны.
|
||
// QueuePendingStats — фактический backlog очереди.
|
||
// Глубина = lag (сообщения, которые группа ещё НЕ прочитала) +
|
||
// pending (прочитанные, но не подтверждённые ack). Ранее считали только
|
||
// pending через XPENDING — это не видело очередь при мёртвом worker'е,
|
||
// потому что сообщения ещё никем не были прочитаны.
|
||
type QueuePendingStats struct {
|
||
Count int64
|
||
OldestAgeSeconds float64
|
||
}
|
||
|
||
// PendingStats — backlog группы и возраст старейшего НЕобработанного сообщения.
|
||
// Возраст = минимум из (a) старейшего pending entry и (b) первого непрочитанного
|
||
// сообщения стрима (идёт сразу за last-delivered-id группы).
|
||
func (q *Queue) PendingStats(ctx context.Context) (QueuePendingStats, error) {
|
||
var st QueuePendingStats
|
||
|
||
groups, err := q.rdb.XInfoGroups(ctx, QueueStreamKey).Result()
|
||
if err != nil {
|
||
// Поток или группа ещё не созданы — очереди нет, это не ошибка.
|
||
if strings.Contains(err.Error(), "NOGROUP") || strings.Contains(err.Error(), "no such key") {
|
||
return st, nil
|
||
}
|
||
return st, fmt.Errorf("xinfo groups: %w", err)
|
||
}
|
||
|
||
var lag int64
|
||
var lastDelivered string
|
||
for _, g := range groups {
|
||
if g.Name != QueueGroup {
|
||
continue
|
||
}
|
||
if g.Lag > 0 { // lag может быть -1, когда Redis не может оценить
|
||
lag = g.Lag
|
||
}
|
||
lastDelivered = g.LastDeliveredID
|
||
st.Count += g.Pending
|
||
}
|
||
st.Count += lag
|
||
if st.Count == 0 {
|
||
return st, nil
|
||
}
|
||
|
||
var oldestMS int64
|
||
consider := func(ms int64) {
|
||
if ms > 0 && (oldestMS == 0 || ms < oldestMS) {
|
||
oldestMS = ms
|
||
}
|
||
}
|
||
|
||
// (a) старейший pending entry. В go-redis v9: XPending.Lower (не Min).
|
||
if p, perr := q.rdb.XPending(ctx, QueueStreamKey, QueueGroup).Result(); perr == nil && p.Count > 0 && p.Lower != "" {
|
||
if ms, ok := parseStreamMS(p.Lower); ok {
|
||
consider(ms)
|
||
}
|
||
}
|
||
// (b) первое непрочитанное сообщение (сразу за last-delivered-id)
|
||
if lag > 0 && lastDelivered != "" {
|
||
msgs, rerr := q.rdb.XRangeN(ctx, QueueStreamKey, nextStreamID(lastDelivered), "+", 1).Result()
|
||
if rerr == nil && len(msgs) == 1 {
|
||
if ms, ok := parseStreamMS(msgs[0].ID); ok {
|
||
consider(ms)
|
||
}
|
||
}
|
||
}
|
||
|
||
if oldestMS > 0 {
|
||
age := float64(time.Now().UnixMilli()-oldestMS) / 1000.0
|
||
if age < 0 {
|
||
age = 0
|
||
}
|
||
st.OldestAgeSeconds = age
|
||
}
|
||
return st, nil
|
||
}
|
||
|
||
// parseStreamMS извлекает миллисекундную часть id вида "<ms>-<seq>".
|
||
func parseStreamMS(id string) (int64, bool) {
|
||
msPart, _, _ := strings.Cut(id, "-")
|
||
ms, err := strconv.ParseInt(msPart, 10, 64)
|
||
if err != nil {
|
||
return 0, false
|
||
}
|
||
return ms, true
|
||
}
|
||
|
||
// nextStreamID возвращает id, следующий за данным (для XRANGE от границы чтения).
|
||
func nextStreamID(id string) string {
|
||
msPart, seqPart, found := strings.Cut(id, "-")
|
||
if !found {
|
||
return "-"
|
||
}
|
||
ms, err1 := strconv.ParseInt(msPart, 10, 64)
|
||
seq, err2 := strconv.ParseInt(seqPart, 10, 64)
|
||
if err1 != nil || err2 != nil {
|
||
return "-"
|
||
}
|
||
return fmt.Sprintf("%d-%d", ms, seq+1)
|
||
}
|