219bfd0493
* middleware/metrics: add more metrics middleware/cache: Add metrics for number of elements in the cache. Also export the total size. Update README to detail the new metrics. middleware/metrics Move metrics into subpackage called "vars". This breaks the import cycle and is cleaner. This allows vars.Report to be used in the the dnsserver to log refused queries. middleware/metrics: tests Add tests to the metrics framework. The metrics/test subpackage allows scraping of the local server. Do a few test scrape of the metrics that are defined in the metrics middleware. This also allows metrics integration tests to check if the caching and dnssec middleware export their metrics correctly. * update README * typos * fix tests
124 lines
2.6 KiB
Go
124 lines
2.6 KiB
Go
package cache
|
|
|
|
import (
|
|
"strconv"
|
|
"time"
|
|
|
|
"github.com/miekg/coredns/core/dnsserver"
|
|
"github.com/miekg/coredns/middleware"
|
|
|
|
"github.com/hashicorp/golang-lru"
|
|
"github.com/mholt/caddy"
|
|
)
|
|
|
|
func init() {
|
|
caddy.RegisterPlugin("cache", caddy.Plugin{
|
|
ServerType: "dns",
|
|
Action: setup,
|
|
})
|
|
}
|
|
|
|
func setup(c *caddy.Controller) error {
|
|
ca, err := cacheParse(c)
|
|
if err != nil {
|
|
return middleware.Error("cache", err)
|
|
}
|
|
dnsserver.GetConfig(c).AddMiddleware(func(next middleware.Handler) middleware.Handler {
|
|
ca.Next = next
|
|
return ca
|
|
})
|
|
|
|
// Export the capacity for the metrics. This only happens once, because this is a re-load change only.
|
|
cacheCapacity.WithLabelValues(Success).Set(float64(ca.pcap))
|
|
cacheCapacity.WithLabelValues(Denial).Set(float64(ca.ncap))
|
|
|
|
return nil
|
|
}
|
|
|
|
func cacheParse(c *caddy.Controller) (*Cache, error) {
|
|
|
|
ca := &Cache{pcap: defaultCap, ncap: defaultCap, pttl: maxTTL, nttl: maxNTTL}
|
|
|
|
for c.Next() {
|
|
// cache [ttl] [zones..]
|
|
origins := make([]string, len(c.ServerBlockKeys))
|
|
copy(origins, c.ServerBlockKeys)
|
|
args := c.RemainingArgs()
|
|
|
|
if len(args) > 0 {
|
|
// first args may be just a number, then it is the ttl, if not it is a zone
|
|
ttl, err := strconv.Atoi(args[0])
|
|
if err == nil {
|
|
ca.pttl = time.Duration(ttl) * time.Second
|
|
ca.nttl = time.Duration(ttl) * time.Second
|
|
args = args[1:]
|
|
}
|
|
if len(args) > 0 {
|
|
copy(origins, args)
|
|
}
|
|
}
|
|
|
|
// Refinements? In an extra block.
|
|
for c.NextBlock() {
|
|
switch c.Val() {
|
|
// first number is cap, second is an new ttl
|
|
case Success:
|
|
args := c.RemainingArgs()
|
|
if len(args) == 0 {
|
|
return nil, c.ArgErr()
|
|
}
|
|
pcap, err := strconv.Atoi(args[0])
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
ca.pcap = pcap
|
|
if len(args) > 1 {
|
|
pttl, err := strconv.Atoi(args[1])
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
ca.pttl = time.Duration(pttl) * time.Second
|
|
}
|
|
case Denial:
|
|
args := c.RemainingArgs()
|
|
if len(args) == 0 {
|
|
return nil, c.ArgErr()
|
|
}
|
|
ncap, err := strconv.Atoi(args[0])
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
ca.ncap = ncap
|
|
if len(args) > 1 {
|
|
nttl, err := strconv.Atoi(args[1])
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
ca.nttl = time.Duration(nttl) * time.Second
|
|
}
|
|
default:
|
|
return nil, c.ArgErr()
|
|
}
|
|
}
|
|
|
|
for i := range origins {
|
|
origins[i] = middleware.Host(origins[i]).Normalize()
|
|
}
|
|
|
|
var err error
|
|
ca.Zones = origins
|
|
|
|
ca.pcache, err = lru.New(ca.pcap)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
ca.ncache, err = lru.New(ca.ncap)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return ca, nil
|
|
}
|
|
|
|
return nil, nil
|
|
}
|