daxi20/AdGuardHome
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Pull request: 2509 type-safety vol.2

Browse Source 
Merge in DNS/adguard-home from 2509-type-safety-vol2 to master

Updates #2509.

Squashed commit of the following:

commit c944e4e0a9949fc894c90b4bc1f739148a67fd9d
Author: Eugene Burkov <e.burkov@adguard.com>
Date:   Thu Jan 21 19:36:20 2021 +0300

    all: imp docs

commit e8ac1815c492b0a9434596e35a48755cac2b9f3b
Author: Eugene Burkov <e.burkov@adguard.com>
Date:   Wed Jan 20 12:38:48 2021 +0300

    all: imp JSON encoding, decoding
This commit is contained in:
Eugene Burkov
2021-01-21 19:55:41 +03:00
parent 7fab31beae
commit d9482b7588
10 changed files with 226 additions and 189 deletions
Download Patch File Download Diff File Expand all files Collapse all files

37
internal/stats/http.go
View File

@@ -19,26 +19,43 @@ func httpError(r *http.Request, w http.ResponseWriter, code int, format string,
http.Error(w, text, code)
}
// Return data
// statsResponse is a response for getting statistics.
type statsResponse struct {
TimeUnits string `json:"time_units"`
NumDNSQueries uint64 `json:"num_dns_queries"`
NumBlockedFiltering uint64 `json:"num_blocked_filtering"`
NumReplacedSafebrowsing uint64 `json:"num_replaced_safebrowsing"`
NumReplacedSafesearch uint64 `json:"num_replaced_safesearch"`
NumReplacedParental uint64 `json:"num_replaced_parental"`
AvgProcessingTime float64 `json:"avg_processing_time"`
TopQueried []map[string]uint64 `json:"top_queried_domains"`
TopClients []map[string]uint64 `json:"top_clients"`
TopBlocked []map[string]uint64 `json:"top_blocked_domains"`
DNSQueries []uint64 `json:"dns_queries"`
BlockedFiltering []uint64 `json:"blocked_filtering"`
ReplacedSafebrowsing []uint64 `json:"replaced_safebrowsing"`
ReplacedParental []uint64 `json:"replaced_parental"`
}
// handleStats is a handler for getting statistics.
func (s *statsCtx) handleStats(w http.ResponseWriter, r *http.Request) {
start := time.Now()
d := s.getData()
response, ok := s.getData()
log.Debug("Stats: prepared data in %v", time.Since(start))
if d == nil {
if !ok {
httpError(r, w, http.StatusInternalServerError, "Couldn't get statistics data")
return
}
data, err := json.Marshal(d)
if err != nil {
httpError(r, w, http.StatusInternalServerError, "json encode: %s", err)
return
}
w.Header().Set("Content-Type", "application/json")
_, err = w.Write(data)
err := json.NewEncoder(w).Encode(response)
if err != nil {
httpError(r, w, http.StatusInternalServerError, "json encode: %s", err)

35
internal/stats/stats_test.go
View File

@@ -50,34 +50,36 @@ func TestStats(t *testing.T) {
e.Time = 123456
s.Update(e)
d := s.getData()
d, ok := s.getData()
assert.True(t, ok)
a := []uint64{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2}
assert.True(t, UIntArrayEquals(d["dns_queries"].([]uint64), a))
assert.True(t, UIntArrayEquals(d.DNSQueries, a))
a = []uint64{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1}
assert.True(t, UIntArrayEquals(d["blocked_filtering"].([]uint64), a))
assert.True(t, UIntArrayEquals(d.BlockedFiltering, a))
a = []uint64{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
assert.True(t, UIntArrayEquals(d["replaced_safebrowsing"].([]uint64), a))
assert.True(t, UIntArrayEquals(d.ReplacedSafebrowsing, a))
a = []uint64{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
assert.True(t, UIntArrayEquals(d["replaced_parental"].([]uint64), a))
assert.True(t, UIntArrayEquals(d.ReplacedParental, a))
m := d["top_queried_domains"].([]map[string]uint64)
m := d.TopQueried
assert.EqualValues(t, 1, m[0]["domain"])
m = d["top_blocked_domains"].([]map[string]uint64)
m = d.TopBlocked
assert.EqualValues(t, 1, m[0]["domain"])
m = d["top_clients"].([]map[string]uint64)
m = d.TopClients
assert.EqualValues(t, 2, m[0]["127.0.0.1"])
assert.EqualValues(t, 2, d["num_dns_queries"].(uint64))
assert.EqualValues(t, 1, d["num_blocked_filtering"].(uint64))
assert.EqualValues(t, 0, d["num_replaced_safebrowsing"].(uint64))
assert.EqualValues(t, 0, d["num_replaced_safesearch"].(uint64))
assert.EqualValues(t, 0, d["num_replaced_parental"].(uint64))
assert.EqualValues(t, 0.123456, d["avg_processing_time"].(float64))
assert.EqualValues(t, 2, d.NumDNSQueries)
assert.EqualValues(t, 1, d.NumBlockedFiltering)
assert.EqualValues(t, 0, d.NumReplacedSafebrowsing)
assert.EqualValues(t, 0, d.NumReplacedSafesearch)
assert.EqualValues(t, 0, d.NumReplacedParental)
assert.EqualValues(t, 0.123456, d.AvgProcessingTime)
topClients := s.GetTopClientsIP(2)
assert.True(t, net.IP{127, 0, 0, 1}.Equal(topClients[0]))
@@ -120,8 +122,9 @@ func TestLargeNumbers(t *testing.T) {
}
}
d := s.getData()
assert.EqualValues(t, int(hour)*n, d["num_dns_queries"])
d, ok := s.getData()
assert.True(t, ok)
assert.EqualValues(t, int(hour)*n, d.NumDNSQueries)
s.Close()
os.Remove(conf.Filename)

45
internal/stats/unit.go
View File

@@ -545,10 +545,9 @@ func (s *statsCtx) loadUnits(limit uint32) ([]*unitDB, uint32) {
* parental-blocked
These values are just the sum of data for all units.
*/
func (s *statsCtx) getData() map[string]interface{} {
func (s *statsCtx) getData() (statsResponse, bool) {
limit := s.conf.limit
d := map[string]interface{}{}
timeUnit := Hours
if limit/24 > 7 {
timeUnit = Days
@@ -556,7 +555,7 @@ func (s *statsCtx) getData() map[string]interface{} {
units, firstID := s.loadUnits(limit)
if units == nil {
return nil
return statsResponse{}, false
}
// per time unit counters:
@@ -604,18 +603,14 @@ func (s *statsCtx) getData() map[string]interface{} {
log.Fatalf("len(dnsQueries) != limit: %d %d", len(dnsQueries), limit)
}
statsData := map[string]interface{}{
"dns_queries": dnsQueries,
"blocked_filtering": statsCollector(func(u *unitDB) (num uint64) { return u.NResult[RFiltered] }),
"replaced_safebrowsing": statsCollector(func(u *unitDB) (num uint64) { return u.NResult[RSafeBrowsing] }),
"replaced_parental": statsCollector(func(u *unitDB) (num uint64) { return u.NResult[RParental] }),
"top_queried_domains": topsCollector(maxDomains, func(u *unitDB) (pairs []countPair) { return u.Domains }),
"top_blocked_domains": topsCollector(maxDomains, func(u *unitDB) (pairs []countPair) { return u.BlockedDomains }),
"top_clients": topsCollector(maxClients, func(u *unitDB) (pairs []countPair) { return u.Clients }),
}
for dataKey, dataValue := range statsData {
d[dataKey] = dataValue
data := statsResponse{
DNSQueries: dnsQueries,
BlockedFiltering: statsCollector(func(u *unitDB) (num uint64) { return u.NResult[RFiltered] }),
ReplacedSafebrowsing: statsCollector(func(u *unitDB) (num uint64) { return u.NResult[RSafeBrowsing] }),
ReplacedParental: statsCollector(func(u *unitDB) (num uint64) { return u.NResult[RParental] }),
TopQueried: topsCollector(maxDomains, func(u *unitDB) (pairs []countPair) { return u.Domains }),
TopBlocked: topsCollector(maxDomains, func(u *unitDB) (pairs []countPair) { return u.BlockedDomains }),
TopClients: topsCollector(maxClients, func(u *unitDB) (pairs []countPair) { return u.Clients }),
}
// total counters:
@@ -635,24 +630,22 @@ func (s *statsCtx) getData() map[string]interface{} {
sum.NResult[RParental] += u.NResult[RParental]
}
d["num_dns_queries"] = sum.NTotal
d["num_blocked_filtering"] = sum.NResult[RFiltered]
d["num_replaced_safebrowsing"] = sum.NResult[RSafeBrowsing]
d["num_replaced_safesearch"] = sum.NResult[RSafeSearch]
d["num_replaced_parental"] = sum.NResult[RParental]
data.NumDNSQueries = sum.NTotal
data.NumBlockedFiltering = sum.NResult[RFiltered]
data.NumReplacedSafebrowsing = sum.NResult[RSafeBrowsing]
data.NumReplacedSafesearch = sum.NResult[RSafeSearch]
data.NumReplacedParental = sum.NResult[RParental]
avgTime := float64(0)
if timeN != 0 {
avgTime = float64(sum.TimeAvg/uint32(timeN)) / 1000000
data.AvgProcessingTime = float64(sum.TimeAvg/uint32(timeN)) / 1000000
}
d["avg_processing_time"] = avgTime
d["time_units"] = "hours"
data.TimeUnits = "hours"
if timeUnit == Days {
d["time_units"] = "days"
data.TimeUnits = "days"
}
return d
return data, true
}
func (s *statsCtx) GetTopClientsIP(maxCount uint) []net.IP {