feat: use postgres

notification/internal/worker/sqlretention.go

@@ -0,0 +1,161 @@
+package worker
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"log/slog"
+	"time"
+)
+
+// SQLRetentionStore performs the durable DELETE statements applied by the
+// retention worker. Implementations are typically the umbrella PostgreSQL
+// notification store; the interface keeps the worker decoupled from the
+// store package.
+type SQLRetentionStore interface {
+	// DeleteRecordsOlderThan removes records rows whose accepted_at predates
+	// cutoff. Cascading FKs drop routes and dead_letters owned by the deleted
+	// rows.
+	DeleteRecordsOlderThan(ctx context.Context, cutoff time.Time) (int64, error)
+
+	// DeleteMalformedIntentsOlderThan removes malformed-intent rows whose
+	// recorded_at predates cutoff.
+	DeleteMalformedIntentsOlderThan(ctx context.Context, cutoff time.Time) (int64, error)
+}
+
+// SQLRetentionConfig stores the dependencies and policy used by
+// SQLRetentionWorker.
+type SQLRetentionConfig struct {
+	// Store applies the durable DELETE statements.
+	Store SQLRetentionStore
+
+	// RecordRetention bounds how long records (and their cascaded routes and
+	// dead_letters) survive after acceptance.
+	RecordRetention time.Duration
+
+	// MalformedIntentRetention bounds how long malformed-intent rows survive
+	// after recorded_at.
+	MalformedIntentRetention time.Duration
+
+	// CleanupInterval stores the wall-clock period between two retention
+	// passes.
+	CleanupInterval time.Duration
+
+	// Clock provides the wall-clock used to compute cutoff timestamps.
+	Clock Clock
+}
+
+// SQLRetentionWorker periodically deletes records and malformed-intent rows
+// whose retention window has expired. The worker replaces the per-key
+// Redis EXPIRE eviction that maintained TTLs on the previous Redis-backed
+// notification keyspace.
+type SQLRetentionWorker struct {
+	store                    SQLRetentionStore
+	recordRetention          time.Duration
+	malformedIntentRetention time.Duration
+	cleanupInterval          time.Duration
+	clock                    Clock
+	logger                   *slog.Logger
+}
+
+// NewSQLRetentionWorker constructs the periodic retention worker.
+func NewSQLRetentionWorker(cfg SQLRetentionConfig, logger *slog.Logger) (*SQLRetentionWorker, error) {
+	switch {
+	case cfg.Store == nil:
+		return nil, errors.New("new sql retention worker: nil store")
+	case cfg.RecordRetention <= 0:
+		return nil, errors.New("new sql retention worker: non-positive record retention")
+	case cfg.MalformedIntentRetention <= 0:
+		return nil, errors.New("new sql retention worker: non-positive malformed intent retention")
+	case cfg.CleanupInterval <= 0:
+		return nil, errors.New("new sql retention worker: non-positive cleanup interval")
+	case cfg.Clock == nil:
+		return nil, errors.New("new sql retention worker: nil clock")
+	}
+	if logger == nil {
+		logger = slog.Default()
+	}
+
+	return &SQLRetentionWorker{
+		store:                    cfg.Store,
+		recordRetention:          cfg.RecordRetention,
+		malformedIntentRetention: cfg.MalformedIntentRetention,
+		cleanupInterval:          cfg.CleanupInterval,
+		clock:                    cfg.Clock,
+		logger:                   logger.With("component", "sql_retention_worker"),
+	}, nil
+}
+
+// Run starts the retention loop and blocks until ctx is canceled.
+func (worker *SQLRetentionWorker) Run(ctx context.Context) error {
+	if ctx == nil {
+		return errors.New("run sql retention worker: nil context")
+	}
+	if err := ctx.Err(); err != nil {
+		return err
+	}
+	if worker == nil {
+		return errors.New("run sql retention worker: nil worker")
+	}
+
+	worker.logger.Info("sql retention worker started",
+		"record_retention", worker.recordRetention.String(),
+		"malformed_intent_retention", worker.malformedIntentRetention.String(),
+		"cleanup_interval", worker.cleanupInterval.String(),
+	)
+	defer worker.logger.Info("sql retention worker stopped")
+
+	// First pass runs immediately so a freshly started service does not wait
+	// one full interval before evicting stale rows.
+	worker.runOnce(ctx)
+
+	ticker := time.NewTicker(worker.cleanupInterval)
+	defer ticker.Stop()
+
+	for {
+		select {
+		case <-ctx.Done():
+			return ctx.Err()
+		case <-ticker.C:
+			worker.runOnce(ctx)
+		}
+	}
+}
+
+// Shutdown stops the retention worker within ctx.
+func (worker *SQLRetentionWorker) Shutdown(ctx context.Context) error {
+	if ctx == nil {
+		return errors.New("shutdown sql retention worker: nil context")
+	}
+	return nil
+}
+
+func (worker *SQLRetentionWorker) runOnce(ctx context.Context) {
+	now := worker.clock.Now().UTC()
+
+	recordCutoff := now.Add(-worker.recordRetention)
+	if deleted, err := worker.store.DeleteRecordsOlderThan(ctx, recordCutoff); err != nil {
+		worker.logger.Warn("delete expired records failed",
+			"cutoff", recordCutoff,
+			"error", fmt.Sprintf("%v", err),
+		)
+	} else if deleted > 0 {
+		worker.logger.Info("expired records deleted",
+			"cutoff", recordCutoff,
+			"deleted", deleted,
+		)
+	}
+
+	malformedCutoff := now.Add(-worker.malformedIntentRetention)
+	if deleted, err := worker.store.DeleteMalformedIntentsOlderThan(ctx, malformedCutoff); err != nil {
+		worker.logger.Warn("delete expired malformed intents failed",
+			"cutoff", malformedCutoff,
+			"error", fmt.Sprintf("%v", err),
+		)
+	} else if deleted > 0 {
+		worker.logger.Info("expired malformed intents deleted",
+			"cutoff", malformedCutoff,
+			"deleted", deleted,
+		)
+	}
+}