release: 1.6.0

Add 30-day send statistics and auto level-2 rate limits on the domain page. Close Unreleased; pin compose and docs to 1.6.0. Co-authored-by: Cursor <cursoragent@cursor.com>
2026-08-18 22:26:51 +03:00
parent 8538b8d5f6
commit c1ec4fbd79
27 changed files with 1092 additions and 140 deletions
@@ -0,0 +1,166 @@
+package store
+
+import (
+	"database/sql"
+	"fmt"
+	"log"
+	"math"
+	"time"
+)
+
+// RecalcAllAutoRateLimits recomputes max_messages for every auto-mode limit.
+// Store errors for individual rows are logged and skipped (fail-open on the
+// last successfully written limit). Returns how many rows were updated.
+func (s *Store) RecalcAllAutoRateLimits(retentionDays, l1Max, l1Window int) (int, error) {
+	rows, err := s.listAutoRateLimits()
+	if err != nil {
+		return 0, err
+	}
+	var updated int
+	for _, rl := range rows {
+		if err := s.recalcAutoRateLimit(rl, retentionDays, l1Max, l1Window); err != nil {
+			log.Printf("store: auto rate-limit recalc %s ref %d: %v", rl.Scope, rl.RefID, err)
+			continue
+		}
+		updated++
+	}
+	return updated, nil
+}
+
+// RecalcAutoRateLimit recomputes one auto-mode limit. Returns an error when
+// the row is missing or not in auto mode.
+func (s *Store) RecalcAutoRateLimit(scope string, refID int64, retentionDays, l1Max, l1Window int) error {
+	rl, ok, err := s.GetRateLimit(scope, refID)
+	if err != nil {
+		return err
+	}
+	if !ok || !rl.IsAuto() {
+		return fmt.Errorf("rate limit not in auto mode")
+	}
+	rl.Scope, rl.RefID = scope, refID
+	return s.recalcAutoRateLimit(rl, retentionDays, l1Max, l1Window)
+}
+
+func (s *Store) listAutoRateLimits() ([]RateLimit, error) {
+	rows, err := s.db.Query(
+		`SELECT scope, ref_id, allowed_ips, max_messages, window_seconds, mode, auto_multiplier, auto_updated_at
+		 FROM rate_limits WHERE mode = ?`, RateLimitModeAuto,
+	)
+	if err != nil {
+		return nil, fmt.Errorf("list auto rate limits: %w", err)
+	}
+	defer rows.Close()
+
+	var out []RateLimit
+	for rows.Next() {
+		var scope string
+		var refID int64
+		var ips sql.NullString
+		var maxMsgs, windowSecs sql.NullInt64
+		var mode sql.NullString
+		var autoMult sql.NullFloat64
+		var autoUpdated sql.NullString
+		if err := rows.Scan(&scope, &refID, &ips, &maxMsgs, &windowSecs, &mode, &autoMult, &autoUpdated); err != nil {
+			return nil, fmt.Errorf("scan auto rate limit: %w", err)
+		}
+		rl := RateLimit{
+			Scope:         scope,
+			RefID:         refID,
+			AllowedIPs:    splitIPs(ips.String),
+			MaxMessages:   int(maxMsgs.Int64),
+			WindowSeconds: int(windowSecs.Int64),
+			Mode:          mode.String,
+		}
+		if autoMult.Valid {
+			rl.AutoMultiplier = autoMult.Float64
+		}
+		if autoUpdated.Valid {
+			rl.AutoUpdatedAt, _ = time.Parse(time.RFC3339, autoUpdated.String)
+		}
+		out = append(out, rl)
+	}
+	return out, rows.Err()
+}
+
+func (s *Store) recalcAutoRateLimit(rl RateLimit, retentionDays, l1Max, l1Window int) error {
+	if !rl.IsAuto() {
+		return fmt.Errorf("not auto mode")
+	}
+	mult := rl.AutoMultiplier
+	if mult <= 0 {
+		mult = DefaultAutoMultiplier
+	}
+
+	var stats SendStats
+	var domainMax int
+	var domainActive bool
+
+	switch rl.Scope {
+	case RateLimitScopeDomain:
+		d, err := s.GetDomain(rl.RefID)
+		if err != nil {
+			return err
+		}
+		stats, err = s.DomainSendStats(d.Name, retentionDays, d.CreatedAt)
+		if err != nil {
+			return err
+		}
+	case RateLimitScopeApp:
+		a, err := s.GetApplication(rl.RefID)
+		if err != nil {
+			return err
+		}
+		stats, err = s.AppSendStats(a.Login, retentionDays, a.CreatedAt)
+		if err != nil {
+			return err
+		}
+		domainRL, ok, err := s.GetRateLimit(RateLimitScopeDomain, a.DomainID)
+		if err != nil {
+			return err
+		}
+		domainActive = ok && domainRL.Active()
+		if domainActive {
+			domainMax = domainRL.MaxMessages
+		}
+	default:
+		return fmt.Errorf("unknown scope %q", rl.Scope)
+	}
+
+	maxMsgs := computeAutoMaxMessages(stats, mult, l1Max)
+	if rl.Scope == RateLimitScopeApp {
+		maxMsgs = adjustAppAutoMax(maxMsgs, domainMax, domainActive, l1Max)
+	}
+
+	rl.MaxMessages = maxMsgs
+	rl.WindowSeconds = l1Window
+	rl.AutoUpdatedAt = time.Now().UTC()
+	if rl.AutoMultiplier <= 0 {
+		rl.AutoMultiplier = mult
+	}
+
+	return s.SetRateLimit(rl)
+}
+
+func computeAutoMaxMessages(stats SendStats, multiplier float64, l1Max int) int {
+	if stats.Total == 0 {
+		return 0
+	}
+	max := int(math.Ceil(stats.AvgPerHour * multiplier))
+	if max > l1Max {
+		max = l1Max
+	}
+	return max
+}
+
+func adjustAppAutoMax(appMax, domainMax int, domainActive bool, l1Max int) int {
+	if appMax <= 0 {
+		return 0
+	}
+	if domainActive && appMax <= domainMax {
+		appMax = domainMax + 1
+		if appMax > l1Max {
+			return 0
+		}
+	}
+	return appMax
+}