all: sync with master; upd chlog

internal/stats/stats.go

@@ -16,6 +16,7 @@ import (
 	"github.com/AdguardTeam/golibs/errors"
 	"github.com/AdguardTeam/golibs/log"
 	"github.com/AdguardTeam/golibs/stringutil"
+	"github.com/AdguardTeam/golibs/timeutil"
 	"go.etcd.io/bbolt"
 )
 
@@ -25,7 +26,23 @@ func checkInterval(days uint32) (ok bool) {
 	return days == 0 || days == 1 || days == 7 || days == 30 || days == 90
 }
 
+// validateIvl returns an error if ivl is less than an hour or more than a
+// year.
+func validateIvl(ivl time.Duration) (err error) {
+	if ivl < time.Hour {
+		return errors.Error("less than an hour")
+	}
+
+	if ivl > timeutil.Day*365 {
+		return errors.Error("more than a year")
+	}
+
+	return nil
+}
+
 // Config is the configuration structure for the statistics collecting.
+//
+// Do not alter any fields of this structure after using it.
 type Config struct {
 	// UnitID is the function to generate the identifier for current unit.  If
 	// nil, the default function is used, see newUnitID.
@@ -35,22 +52,24 @@ type Config struct {
 	// interface.
 	ConfigModified func()
 
+	// ShouldCountClient returns client's ignore setting.
+	ShouldCountClient func([]string) bool
+
 	// HTTPRegister is the function that registers handlers for the stats
 	// endpoints.
 	HTTPRegister aghhttp.RegisterFunc
 
+	// Ignored is the list of host names, which should not be counted.
+	Ignored *stringutil.Set
+
 	// Filename is the name of the database file.
 	Filename string
 
-	// LimitDays is the maximum number of days to collect statistics into the
-	// current unit.
-	LimitDays uint32
+	// Limit is an upper limit for collecting statistics.
+	Limit time.Duration
 
 	// Enabled tells if the statistics are enabled.
 	Enabled bool
-
-	// Ignored is the list of host names, which should not be counted.
-	Ignored *stringutil.Set
 }
 
 // Interface is the statistics interface to be used by other packages.
@@ -71,7 +90,7 @@ type Interface interface {
 	WriteDiskConfig(dc *Config)
 
 	// ShouldCount returns true if request for the host should be counted.
-	ShouldCount(host string, qType, qClass uint16) bool
+	ShouldCount(host string, qType, qClass uint16, ids []string) bool
 }
 
 // StatsCtx collects the statistics and flushes it to the database.  Its default
@@ -96,23 +115,23 @@ type StatsCtx struct {
 	// interface.
 	configModified func()
 
-	// filename is the name of database file.
-	filename string
-
-	// lock protects all the fields below.
-	lock sync.Mutex
-
-	// enabled tells if the statistics are enabled.
-	enabled bool
-
-	// limitHours is the maximum number of hours to collect statistics into the
-	// current unit.
-	//
-	// TODO(s.chzhen):  Rewrite to use time.Duration.
-	limitHours uint32
+	// confMu protects ignored, limit, and enabled.
+	confMu *sync.RWMutex
 
 	// ignored is the list of host names, which should not be counted.
 	ignored *stringutil.Set
+
+	// shouldCountClient returns client's ignore setting.
+	shouldCountClient func([]string) bool
+
+	// filename is the name of database file.
+	filename string
+
+	// limit is an upper limit for collecting statistics.
+	limit time.Duration
+
+	// enabled tells if the statistics are enabled.
+	enabled bool
 }
 
 // New creates s from conf and properly initializes it.  Don't use s before
@@ -120,17 +139,28 @@ type StatsCtx struct {
 func New(conf Config) (s *StatsCtx, err error) {
 	defer withRecovered(&err)
 
+	err = validateIvl(conf.Limit)
+	if err != nil {
+		return nil, fmt.Errorf("unsupported interval: %w", err)
+	}
+
+	if conf.ShouldCountClient == nil {
+		return nil, errors.Error("should count client is unspecified")
+	}
+
 	s = &StatsCtx{
-		enabled:        conf.Enabled,
 		currMu:         &sync.RWMutex{},
-		filename:       conf.Filename,
-		configModified: conf.ConfigModified,
 		httpRegister:   conf.HTTPRegister,
-		ignored:        conf.Ignored,
-	}
-	if s.limitHours = conf.LimitDays * 24; !checkInterval(conf.LimitDays) {
-		s.limitHours = 24
+		configModified: conf.ConfigModified,
+		filename:       conf.Filename,
+
+		confMu:            &sync.RWMutex{},
+		ignored:           conf.Ignored,
+		shouldCountClient: conf.ShouldCountClient,
+		limit:             conf.Limit,
+		enabled:           conf.Enabled,
 	}
+
 	if s.unitIDGen = newUnitID; conf.UnitID != nil {
 		s.unitIDGen = conf.UnitID
 	}
@@ -150,7 +180,7 @@ func New(conf Config) (s *StatsCtx, err error) {
 		return nil, fmt.Errorf("stats: opening a transaction: %w", err)
 	}
 
-	deleted := deleteOldUnits(tx, id-s.limitHours-1)
+	deleted := deleteOldUnits(tx, id-uint32(s.limit.Hours())-1)
 	udb = loadUnitFromDB(tx, id)
 
 	err = finishTxn(tx, deleted > 0)
@@ -228,10 +258,10 @@ func (s *StatsCtx) Close() (err error) {
 
 // Update implements the Interface interface for *StatsCtx.
 func (s *StatsCtx) Update(e Entry) {
-	s.lock.Lock()
-	defer s.lock.Unlock()
+	s.confMu.Lock()
+	defer s.confMu.Unlock()
 
-	if !s.enabled || s.limitHours == 0 {
+	if !s.enabled || s.limit == 0 {
 		return
 	}
 
@@ -260,20 +290,20 @@ func (s *StatsCtx) Update(e Entry) {
 
 // WriteDiskConfig implements the Interface interface for *StatsCtx.
 func (s *StatsCtx) WriteDiskConfig(dc *Config) {
-	s.lock.Lock()
-	defer s.lock.Unlock()
+	s.confMu.RLock()
+	defer s.confMu.RUnlock()
 
-	dc.LimitDays = s.limitHours / 24
+	dc.Ignored = s.ignored.Clone()
+	dc.Limit = s.limit
 	dc.Enabled = s.enabled
-	dc.Ignored = s.ignored
 }
 
 // TopClientsIP implements the [Interface] interface for *StatsCtx.
 func (s *StatsCtx) TopClientsIP(maxCount uint) (ips []netip.Addr) {
-	s.lock.Lock()
-	defer s.lock.Unlock()
+	s.confMu.RLock()
+	defer s.confMu.RUnlock()
 
-	limit := s.limitHours
+	limit := uint32(s.limit.Hours())
 	if !s.enabled || limit == 0 {
 		return nil
 	}
@@ -366,8 +396,8 @@ func (s *StatsCtx) openDB() (err error) {
 func (s *StatsCtx) flush() (cont bool, sleepFor time.Duration) {
 	id := s.unitIDGen()
 
-	s.lock.Lock()
-	defer s.lock.Unlock()
+	s.confMu.Lock()
+	defer s.confMu.Unlock()
 
 	s.currMu.Lock()
 	defer s.currMu.Unlock()
@@ -377,7 +407,7 @@ func (s *StatsCtx) flush() (cont bool, sleepFor time.Duration) {
 		return false, 0
 	}
 
-	limit := s.limitHours
+	limit := uint32(s.limit.Hours())
 	if limit == 0 || ptr.id == id {
 		return true, time.Second
 	}
@@ -436,14 +466,14 @@ func (s *StatsCtx) periodicFlush() {
 	log.Debug("periodic flushing finished")
 }
 
-func (s *StatsCtx) setLimit(limitDays int) {
-	s.lock.Lock()
-	defer s.lock.Unlock()
-
-	if limitDays != 0 {
+// setLimit sets the limit.  s.lock is expected to be locked.
+//
+// TODO(s.chzhen):  Remove it when migration to the new API is over.
+func (s *StatsCtx) setLimit(limit time.Duration) {
+	if limit != 0 {
 		s.enabled = true
-		s.limitHours = uint32(24 * limitDays)
-		log.Debug("stats: set limit: %d days", limitDays)
+		s.limit = limit
+		log.Debug("stats: set limit: %d days", limit/timeutil.Day)
 
 		return
 	}
@@ -558,11 +588,19 @@ func (s *StatsCtx) loadUnits(limit uint32) (units []*unitDB, firstID uint32) {
 }
 
 // ShouldCount returns true if request for the host should be counted.
-func (s *StatsCtx) ShouldCount(host string, _, _ uint16) bool {
+func (s *StatsCtx) ShouldCount(host string, _, _ uint16, ids []string) bool {
+	s.confMu.RLock()
+	defer s.confMu.RUnlock()
+
+	if !s.shouldCountClient(ids) {
+		return false
+	}
+
 	return !s.isIgnored(host)
 }
 
-// isIgnored returns true if the host is in the Ignored list.
+// isIgnored returns true if the host is in the ignored domains list.  It
+// assumes that s.confMu is locked for reading.
 func (s *StatsCtx) isIgnored(host string) bool {
 	return s.ignored.Has(host)
 }