Pull request: querylog imp code

Merge in DNS/adguard-home from querylog-imp-code to master

Squashed commit of the following:

commit a58ad36508a2355b686d314dec51ac0b5e357281
Merge: df5494f2c 941eb1dd7
Author: Dimitry Kolyshev <dkolyshev@adguard.com>
Date:   Wed May 24 15:26:55 2023 +0300

    Merge remote-tracking branch 'origin/master' into querylog-imp-code

commit df5494f2c337736690a3c2a547c2d71858d0378f
Author: Dimitry Kolyshev <dkolyshev@adguard.com>
Date:   Wed May 24 15:24:43 2023 +0300

    querylog: imp code

commit 8c3c2b76dd5858e7b107f222c112e9cde2477fb3
Author: Dimitry Kolyshev <dkolyshev@adguard.com>
Date:   Wed May 24 12:14:15 2023 +0300

    all: lint script

commit be04a4decfaf20a1649d32ecaab3c1c6bb205ffd
Author: Dimitry Kolyshev <dkolyshev@adguard.com>
Date:   Wed May 24 12:03:12 2023 +0300

    querylog: imp code

commit fe7beacff3a5cfcf2332c4998b9c65820284eaf7
Author: Dimitry Kolyshev <dkolyshev@adguard.com>
Date:   Wed May 24 11:57:33 2023 +0300

    querylog: imp docs

commit 2ae239c57d12524fbc092f582842af2ad726c1d0
Author: Dimitry Kolyshev <dkolyshev@adguard.com>
Date:   Wed May 24 11:46:54 2023 +0300

    querylog: imp code

commit 417216cefbf154fa870f8f43468f35e0e345971f
Author: Dimitry Kolyshev <dkolyshev@adguard.com>
Date:   Wed May 24 11:25:44 2023 +0300

    querylog: imp code

commit 514b6ee99113844a4e0dad30dc53703e3220c289
Author: Dimitry Kolyshev <dkolyshev@adguard.com>
Date:   Wed May 24 11:14:13 2023 +0300

    querylog: imp docs

commit 321351a3abb524208daacd5a3a7fbf5f07ab259d
Author: Dimitry Kolyshev <dkolyshev@adguard.com>
Date:   Mon May 22 16:38:31 2023 +0300

    querylog: imp code

commit ee91de5c43210b5bc213f933d411adb894d2e586
Author: Dimitry Kolyshev <dkolyshev@adguard.com>
Date:   Mon May 22 16:01:32 2023 +0300

    querylog: imp code

commit 862ff12177fb769d5cb2ec250eaee538dc91d70a
Author: Dimitry Kolyshev <dkolyshev@adguard.com>
Date:   Mon May 22 15:07:24 2023 +0300

    querylog: imp code

commit cc62c1c4ae8b813d03ccf51b596ba1ebf44d9a1f
Merge: 37ace34e9 24b41100c
Author: Dimitry Kolyshev <dkolyshev@adguard.com>
Date:   Mon May 22 13:09:10 2023 +0300

    Merge remote-tracking branch 'origin/master' into querylog-imp-code

commit 37ace34e91e5189bef6e774db960f40cdaa18270
Author: Dimitry Kolyshev <dkolyshev@adguard.com>
Date:   Mon May 22 11:23:08 2023 +0300

    querylog: imp code

commit 8417815a6349f10b5dbad410ce28aab98bc479fa
Author: Dimitry Kolyshev <dkolyshev@adguard.com>
Date:   Mon May 22 11:08:29 2023 +0300

    querylog: imp docs

commit 4e5cde74d25713f78675aa3e18083b4fb5e619f3
Author: Dimitry Kolyshev <dkolyshev@adguard.com>
Date:   Fri May 19 16:41:34 2023 +0300

    querylog: imp code

commit 3494eab7006240f652a0217d305ac916bd6c3c83
Author: Dimitry Kolyshev <dkolyshev@adguard.com>
Date:   Fri May 19 16:13:08 2023 +0300

    all: lint script

commit 704534ce6278e7d9b1bef30a3acc4e59f25693bc
Author: Dimitry Kolyshev <dkolyshev@adguard.com>
Date:   Fri May 19 16:12:04 2023 +0300

    querylog: imp code

commit 48510102a2fa5187f78067d2b9157dac62f8bb56
Author: Dimitry Kolyshev <dkolyshev@adguard.com>
Date:   Fri May 19 15:52:57 2023 +0300

    querylog: imp code

commit 89c273aea0e6758eb749a2d3bbaf1bc385a57797
Author: Dimitry Kolyshev <dkolyshev@adguard.com>
Date:   Fri May 19 15:40:50 2023 +0300

    querylog: imp code

commit 0057fe64553ad38de0fda10efb9d3512c9a00e45
Author: Dimitry Kolyshev <dkolyshev@adguard.com>
Date:   Fri May 19 13:54:46 2023 +0300

    querylog: imp code

... and 1 more commit

internal/querylog/decode.go

@@ -3,19 +3,24 @@ package querylog
 import (
 	"encoding/base64"
 	"encoding/json"
+	"fmt"
 	"io"
 	"net"
 	"strings"
 	"time"
 
 	"github.com/AdguardTeam/AdGuardHome/internal/filtering"
+	"github.com/AdguardTeam/golibs/errors"
 	"github.com/AdguardTeam/golibs/log"
 	"github.com/AdguardTeam/urlfilter/rules"
 	"github.com/miekg/dns"
 )
 
+// logEntryHandler represents a handler for decoding json token to the logEntry
+// struct.
 type logEntryHandler func(t json.Token, ent *logEntry) error
 
+// logEntryHandlers is the map of log entry decode handlers for various keys.
 var logEntryHandlers = map[string]logEntryHandler{
 	"CID": func(t json.Token, ent *logEntry) error {
 		v, ok := t.(string)
@@ -166,6 +171,7 @@ var logEntryHandlers = map[string]logEntryHandler{
 	},
 }
 
+// decodeResultRuleKey decodes the token of "Rules" type to logEntry struct.
 func decodeResultRuleKey(key string, i int, dec *json.Decoder, ent *logEntry) {
 	var vToken json.Token
 	switch key {
@@ -189,6 +195,8 @@ func decodeResultRuleKey(key string, i int, dec *json.Decoder, ent *logEntry) {
 	}
 }
 
+// decodeVTokenAndAddRule decodes the "Rules" toke as [filtering.ResultRule]
+// and then adds the decoded object to the slice of result rules.
 func decodeVTokenAndAddRule(
 	key string,
 	i int,
@@ -213,6 +221,8 @@ func decodeVTokenAndAddRule(
 	return newRules, vToken
 }
 
+// decodeResultRules parses the dec's tokens into logEntry ent interpreting it
+// as a slice of the result rules.
 func decodeResultRules(dec *json.Decoder, ent *logEntry) {
 	for {
 		delimToken, err := dec.Token()
@@ -224,48 +234,53 @@ func decodeResultRules(dec *json.Decoder, ent *logEntry) {
 			return
 		}
 
-		if d, ok := delimToken.(json.Delim); ok {
-			if d != '[' {
-				log.Debug("decodeResultRules: unexpected delim %q", d)
+		if d, ok := delimToken.(json.Delim); !ok {
+			return
+		} else if d != '[' {
+			log.Debug("decodeResultRules: unexpected delim %q", d)
+		}
+
+		err = decodeResultRuleToken(dec, ent)
+		if err != nil {
+			if err != io.EOF && !errors.Is(err, ErrEndOfToken) {
+				log.Debug("decodeResultRules err: %s", err)
 			}
-		} else {
+
 			return
 		}
+	}
+}
 
-		i := 0
-		for {
-			var keyToken json.Token
-			keyToken, err = dec.Token()
-			if err != nil {
-				if err != io.EOF {
-					log.Debug("decodeResultRules err: %s", err)
-				}
-
-				return
-			}
-
-			if d, ok := keyToken.(json.Delim); ok {
-				switch d {
-				case '}':
-					i++
-				case ']':
-					return
-				default:
-					// Go on.
-				}
-
-				continue
-			}
-
-			key, ok := keyToken.(string)
-			if !ok {
-				log.Debug("decodeResultRules: keyToken is %T (%[1]v) and not string", keyToken)
-
-				return
-			}
-
-			decodeResultRuleKey(key, i, dec, ent)
+// decodeResultRuleToken decodes the tokens of "Rules" type to the logEntry ent.
+func decodeResultRuleToken(dec *json.Decoder, ent *logEntry) (err error) {
+	i := 0
+	for {
+		var keyToken json.Token
+		keyToken, err = dec.Token()
+		if err != nil {
+			// Don't wrap the error, because it's informative enough as is.
+			return err
 		}
+
+		if d, ok := keyToken.(json.Delim); ok {
+			switch d {
+			case '}':
+				i++
+			case ']':
+				return ErrEndOfToken
+			default:
+				// Go on.
+			}
+
+			continue
+		}
+
+		key, ok := keyToken.(string)
+		if !ok {
+			return fmt.Errorf("keyToken is %T (%[1]v) and not string", keyToken)
+		}
+
+		decodeResultRuleKey(key, i, dec, ent)
 	}
 }
 
@@ -322,6 +337,8 @@ func decodeResultReverseHosts(dec *json.Decoder, ent *logEntry) {
 	}
 }
 
+// decodeResultIPList parses the dec's tokens into logEntry ent interpreting it
+// as the result IP addresses list.
 func decodeResultIPList(dec *json.Decoder, ent *logEntry) {
 	for {
 		itemToken, err := dec.Token()
@@ -355,6 +372,8 @@ func decodeResultIPList(dec *json.Decoder, ent *logEntry) {
 	}
 }
 
+// decodeResultDNSRewriteResultKey decodes the token of "DNSRewriteResult" type
+// to the logEntry struct.
 func decodeResultDNSRewriteResultKey(key string, dec *json.Decoder, ent *logEntry) {
 	var err error
 
@@ -395,50 +414,29 @@ func decodeResultDNSRewriteResultKey(key string, dec *json.Decoder, ent *logEntr
 			log.Debug("decodeResultDNSRewriteResultKey response err: %s", err)
 		}
 
-		for rrType, rrValues := range ent.Result.DNSRewriteResult.Response {
-			switch rrType {
-			case
-				dns.TypeA,
-				dns.TypeAAAA:
-				for i, v := range rrValues {
-					s, _ := v.(string)
-					rrValues[i] = net.ParseIP(s)
-				}
-			default:
-				// Go on.
-			}
-		}
+		ent.parseDNSRewriteResultIPs()
 	default:
 		// Go on.
 	}
 }
 
+// decodeResultDNSRewriteResult parses the dec's tokens into logEntry ent
+// interpreting it as the result DNSRewriteResult.
 func decodeResultDNSRewriteResult(dec *json.Decoder, ent *logEntry) {
 	for {
-		keyToken, err := dec.Token()
+		key, err := parseKeyToken(dec)
 		if err != nil {
-			if err != io.EOF {
-				log.Debug("decodeResultDNSRewriteResult err: %s", err)
+			if err != io.EOF && !errors.Is(err, ErrEndOfToken) {
+				log.Debug("decodeResultDNSRewriteResult: %s", err)
 			}
 
 			return
 		}
 
-		if d, ok := keyToken.(json.Delim); ok {
-			if d == '}' {
-				return
-			}
-
+		if key == "" {
 			continue
 		}
 
-		key, ok := keyToken.(string)
-		if !ok {
-			log.Debug("decodeResultDNSRewriteResult: keyToken is %T (%[1]v) and not string", keyToken)
-
-			return
-		}
-
 		decodeResultDNSRewriteResultKey(key, dec, ent)
 	}
 }
@@ -474,34 +472,51 @@ func translateResult(ent *logEntry) {
 	res.IPList = nil
 }
 
+// ErrEndOfToken is an error returned by parse key token when the closing
+// bracket is found.
+const ErrEndOfToken errors.Error = "end of token"
+
+// parseKeyToken parses the dec's token key.
+func parseKeyToken(dec *json.Decoder) (key string, err error) {
+	keyToken, err := dec.Token()
+	if err != nil {
+		return "", err
+	}
+
+	if d, ok := keyToken.(json.Delim); ok {
+		if d == '}' {
+			return "", ErrEndOfToken
+		}
+
+		return "", nil
+	}
+
+	key, ok := keyToken.(string)
+	if !ok {
+		return "", fmt.Errorf("keyToken is %T (%[1]v) and not string", keyToken)
+	}
+
+	return key, nil
+}
+
+// decodeResult decodes a token of "Result" type to logEntry struct.
 func decodeResult(dec *json.Decoder, ent *logEntry) {
 	defer translateResult(ent)
 
 	for {
-		keyToken, err := dec.Token()
+		key, err := parseKeyToken(dec)
 		if err != nil {
-			if err != io.EOF {
-				log.Debug("decodeResult err: %s", err)
+			if err != io.EOF && !errors.Is(err, ErrEndOfToken) {
+				log.Debug("decodeResult: %s", err)
 			}
 
 			return
 		}
 
-		if d, ok := keyToken.(json.Delim); ok {
-			if d == '}' {
-				return
-			}
-
+		if key == "" {
 			continue
 		}
 
-		key, ok := keyToken.(string)
-		if !ok {
-			log.Debug("decodeResult: keyToken is %T (%[1]v) and not string", keyToken)
-
-			return
-		}
-
 		decHandler, ok := resultDecHandlers[key]
 		if ok {
 			decHandler(dec, ent)
@@ -527,13 +542,16 @@ func decodeResult(dec *json.Decoder, ent *logEntry) {
 	}
 }
 
+// resultHandlers is the map of log entry decode handlers for various keys.
 var resultHandlers = map[string]logEntryHandler{
 	"IsFiltered": func(t json.Token, ent *logEntry) error {
 		v, ok := t.(bool)
 		if !ok {
 			return nil
 		}
+
 		ent.Result.IsFiltered = v
+
 		return nil
 	},
 	"Rule": func(t json.Token, ent *logEntry) error {
@@ -578,11 +596,14 @@ var resultHandlers = map[string]logEntryHandler{
 		if !ok {
 			return nil
 		}
+
 		i, err := v.Int64()
 		if err != nil {
 			return err
 		}
+
 		ent.Result.Reason = filtering.Reason(i)
+
 		return nil
 	},
 	"ServiceName": func(t json.Token, ent *logEntry) error {
@@ -607,6 +628,7 @@ var resultHandlers = map[string]logEntryHandler{
 	},
 }
 
+// resultDecHandlers is the map of decode handlers for various keys.
 var resultDecHandlers = map[string]func(dec *json.Decoder, ent *logEntry){
 	"ReverseHosts":     decodeResultReverseHosts,
 	"IPList":           decodeResultIPList,
@@ -614,9 +636,11 @@ var resultDecHandlers = map[string]func(dec *json.Decoder, ent *logEntry){
 	"DNSRewriteResult": decodeResultDNSRewriteResult,
 }
 
+// decodeLogEntry decodes string str to logEntry ent.
 func decodeLogEntry(ent *logEntry, str string) {
 	dec := json.NewDecoder(strings.NewReader(str))
 	dec.UseNumber()
+
 	for {
 		keyToken, err := dec.Token()
 		if err != nil {