e47d881461
* pkg/replace: make it more efficient.
Remove the map that is allocated on every write and make it more static,
but just defining a function that gets called for a label and returns
its value.
Remove the interface definition and just implement what is needed in our
case. Add benchmark test for replace as well.
Extend metadata test to test multiple values (pretty sure this didn't
work, but there wasn't a test for it, so can't be sure).
Update all callers to use it - concurrent use should be fine as we pass
everything by value.
Benchmarks in replacer:
new: BenchmarkReplacer-4 300000 4717 ns/op 240 B/op 8 allocs/op
old: BenchmarkReplacer-4 300000 4368 ns/op 384 B/op 11 allocs/op
Added benchmark function to the old code to test it.
~~~
func BenchmarkReplacer(b *testing.B) {
w := dnstest.NewRecorder(&test.ResponseWriter{})
r := new(dns.Msg)
r.SetQuestion("example.org.", dns.TypeHINFO)
r.MsgHdr.AuthenticatedData = true
b.ResetTimer()
b.ReportAllocs()
repl := New(context.TODO(), r, w, "")
for i := 0; i < b.N; i++ {
repl.Replace("{type} {name} {size}")
}
}
~~~
New code contains (of course a different one). The amount of ops is
more, which might be good to look at some more. For all the allocations
is seems it was quite performant.
This looks to be 50% faster, and there is less allocations in log
plugin:
old: BenchmarkLogged-4 20000 70526 ns/op
new: BenchmarkLogged-4 30000 57558 ns/op
Signed-off-by: Miek Gieben <miek@miek.nl>
* Stickler bot
Signed-off-by: Miek Gieben <miek@miek.nl>
* Improve test coverage
Signed-off-by: Miek Gieben <miek@miek.nl>
* typo
Signed-off-by: Miek Gieben <miek@miek.nl>
* Add test for malformed log lines
Signed-off-by: Miek Gieben <miek@miek.nl>
113 lines
2.4 KiB
Go
113 lines
2.4 KiB
Go
package log
|
|
|
|
import (
|
|
"strings"
|
|
|
|
"github.com/coredns/coredns/core/dnsserver"
|
|
"github.com/coredns/coredns/plugin"
|
|
"github.com/coredns/coredns/plugin/pkg/replacer"
|
|
"github.com/coredns/coredns/plugin/pkg/response"
|
|
|
|
"github.com/mholt/caddy"
|
|
"github.com/miekg/dns"
|
|
)
|
|
|
|
func init() {
|
|
caddy.RegisterPlugin("log", caddy.Plugin{
|
|
ServerType: "dns",
|
|
Action: setup,
|
|
})
|
|
}
|
|
|
|
func setup(c *caddy.Controller) error {
|
|
rules, err := logParse(c)
|
|
if err != nil {
|
|
return plugin.Error("log", err)
|
|
}
|
|
|
|
dnsserver.GetConfig(c).AddPlugin(func(next plugin.Handler) plugin.Handler {
|
|
return Logger{Next: next, Rules: rules, ErrorFunc: dnsserver.DefaultErrorFunc, repl: replacer.New()}
|
|
})
|
|
|
|
return nil
|
|
}
|
|
|
|
func logParse(c *caddy.Controller) ([]Rule, error) {
|
|
var rules []Rule
|
|
|
|
for c.Next() {
|
|
args := c.RemainingArgs()
|
|
length := len(rules)
|
|
|
|
switch len(args) {
|
|
case 0:
|
|
// Nothing specified; use defaults
|
|
rules = append(rules, Rule{
|
|
NameScope: ".",
|
|
Format: DefaultLogFormat,
|
|
Class: make(map[response.Class]struct{}),
|
|
})
|
|
case 1:
|
|
rules = append(rules, Rule{
|
|
NameScope: dns.Fqdn(args[0]),
|
|
Format: DefaultLogFormat,
|
|
Class: make(map[response.Class]struct{}),
|
|
})
|
|
default:
|
|
// Name scopes, and maybe a format specified
|
|
format := DefaultLogFormat
|
|
|
|
if strings.Contains(args[len(args)-1], "{") {
|
|
switch args[len(args)-1] {
|
|
case "{common}":
|
|
format = CommonLogFormat
|
|
case "{combined}":
|
|
format = CombinedLogFormat
|
|
default:
|
|
format = args[len(args)-1]
|
|
}
|
|
|
|
args = args[:len(args)-1]
|
|
}
|
|
|
|
for _, str := range args {
|
|
rules = append(rules, Rule{
|
|
NameScope: dns.Fqdn(str),
|
|
Format: format,
|
|
Class: make(map[response.Class]struct{}),
|
|
})
|
|
}
|
|
}
|
|
|
|
// Class refinements in an extra block.
|
|
classes := make(map[response.Class]struct{})
|
|
for c.NextBlock() {
|
|
switch c.Val() {
|
|
// class followed by combinations of all, denial, error and success.
|
|
case "class":
|
|
classesArgs := c.RemainingArgs()
|
|
if len(classesArgs) == 0 {
|
|
return nil, c.ArgErr()
|
|
}
|
|
for _, c := range classesArgs {
|
|
cls, err := response.ClassFromString(c)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
classes[cls] = struct{}{}
|
|
}
|
|
default:
|
|
return nil, c.ArgErr()
|
|
}
|
|
}
|
|
if len(classes) == 0 {
|
|
classes[response.All] = struct{}{}
|
|
}
|
|
|
|
for i := len(rules) - 1; i >= length; i -= 1 {
|
|
rules[i].Class = classes
|
|
}
|
|
}
|
|
|
|
return rules, nil
|
|
}
|