Ilia Denisov
dcd8de8b00
- pkg/telemetry: shared OTel provider bootstrap (none/stdout/otlp + W3C
propagators + Go runtime metrics); backend/internal/telemetry becomes a thin
facade keeping its gin middleware.
- Telemetry parity: gateway and the Telegram connector gain telemetry runtimes
and config (GATEWAY_/TELEGRAM_ SERVICE_NAME + OTEL_*); otelgrpc instruments the
backend push server, the gateway's backend+connector clients and the connector
server. Default exporter stays none (collector/dashboards are Stage 14).
- Operational metrics (variant attribute on game-scoped ones): game_replay_duration,
game_move_validate_duration, games_started_total, games_abandoned_total,
game_cache_active, chat_messages_total{kind}, gateway edge_request_duration.
Wired via the SetMetrics setter pattern (default no-op meter).
- TODO-3: account.GuestReaper deletes guests with no game seat past
BACKEND_GUEST_RETENTION (default 30d, swept every BACKEND_GUEST_REAP_INTERVAL).
- Tests: pkg/telemetry exporter selection; game/social/edge metric recording via
a manual reader; config (otlp accepted, guest knobs); inttest guest reaper.
- Docs: PLAN.md re-scopes Stage 12 and adds Stage 13 (alphabet-on-wire) + Stage 14
(CI/deploy) with the agreed dictionary-versioning resolution; ARCHITECTURE 11/13,
TESTING, the three READMEs and FUNCTIONAL(+ru) updated.
88 lines
2.8 KiB
Go
88 lines
2.8 KiB
Go
package account
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"time"
|
|
|
|
"github.com/go-jet/jet/v2/postgres"
|
|
"go.uber.org/zap"
|
|
|
|
"scrabble/backend/internal/postgres/jet/backend/table"
|
|
)
|
|
|
|
// ReapAbandonedGuests deletes guest accounts created before olderThan that are
|
|
// not seated in any game. It returns the number deleted.
|
|
//
|
|
// Scope is deliberately "no game seat at all", not merely "no active game": a
|
|
// finished game belongs to the other players' history, and game_players carries no
|
|
// ON DELETE CASCADE to accounts (docs/ARCHITECTURE.md §4), so a guest with any seat
|
|
// is retained (and a delete would be blocked by that foreign key regardless). The
|
|
// dependent rows of a reaped guest — sessions, identities, account_stats — fall
|
|
// away through their own ON DELETE CASCADE foreign keys. Account age is the
|
|
// abandonment signal because sessions are revoke-only with no maintained
|
|
// last_seen_at, so a lingering session never expires on its own.
|
|
func (s *Store) ReapAbandonedGuests(ctx context.Context, olderThan time.Time) (int64, error) {
|
|
stmt := table.Accounts.DELETE().WHERE(
|
|
table.Accounts.IsGuest.EQ(postgres.Bool(true)).
|
|
AND(table.Accounts.CreatedAt.LT(postgres.TimestampzT(olderThan))).
|
|
AND(postgres.NOT(postgres.EXISTS(
|
|
postgres.SELECT(table.GamePlayers.AccountID).
|
|
FROM(table.GamePlayers).
|
|
WHERE(table.GamePlayers.AccountID.EQ(table.Accounts.AccountID)),
|
|
))),
|
|
)
|
|
res, err := stmt.ExecContext(ctx, s.db)
|
|
if err != nil {
|
|
return 0, fmt.Errorf("account: reap guests: %w", err)
|
|
}
|
|
n, err := res.RowsAffected()
|
|
if err != nil {
|
|
return 0, fmt.Errorf("account: reap guests rows affected: %w", err)
|
|
}
|
|
return n, nil
|
|
}
|
|
|
|
// GuestReaper periodically deletes abandoned guest accounts via
|
|
// Store.ReapAbandonedGuests. It mirrors the game turn-timeout sweeper and the
|
|
// matchmaker reaper: one background goroutine, started once from main.
|
|
type GuestReaper struct {
|
|
store *Store
|
|
retention time.Duration
|
|
clock func() time.Time
|
|
log *zap.Logger
|
|
}
|
|
|
|
// NewGuestReaper constructs a reaper deleting guests whose account age exceeds
|
|
// retention. log may be nil.
|
|
func NewGuestReaper(store *Store, retention time.Duration, log *zap.Logger) *GuestReaper {
|
|
if log == nil {
|
|
log = zap.NewNop()
|
|
}
|
|
return &GuestReaper{
|
|
store: store,
|
|
retention: retention,
|
|
clock: func() time.Time { return time.Now().UTC() },
|
|
log: log,
|
|
}
|
|
}
|
|
|
|
// Run reaps abandoned guests on each tick until ctx is cancelled.
|
|
func (r *GuestReaper) Run(ctx context.Context, interval time.Duration) {
|
|
ticker := time.NewTicker(interval)
|
|
defer ticker.Stop()
|
|
for {
|
|
select {
|
|
case <-ctx.Done():
|
|
return
|
|
case <-ticker.C:
|
|
n, err := r.store.ReapAbandonedGuests(ctx, r.clock().Add(-r.retention))
|
|
if err != nil {
|
|
r.log.Warn("guest reap failed", zap.Error(err))
|
|
} else if n > 0 {
|
|
r.log.Info("reaped abandoned guests", zap.Int64("count", n))
|
|
}
|
|
}
|
|
}
|
|
}
|