Files
mtusi2026lab6/src/internal/store/queue.go
T

270 lines
10 KiB
Go
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
// 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)
}