Cache metrics server (#1746)

* plugin/cache: per server metrics

Use per server metrics in the cache plugin as well. This required
some plumbing changes. Also use request.Request more.

* fix cherry-pick

1 files changed, 26 insertions, 32 deletions

diff --git a/plugin/cache/handler.go b/plugin/cache/handler.go
index d6ed0dcad..598640568 100644
--- a/plugin/cache/handler.go
+++ b/plugin/cache/handler.go
@@ -7,6 +7,7 @@ import (
 	"time"
 
 	"github.com/coredns/coredns/plugin"
+	"github.com/coredns/coredns/plugin/metrics"
 	"github.com/coredns/coredns/request"
 
 	"github.com/miekg/dns"
@@ -17,18 +18,16 @@ import (
 func (c *Cache) ServeDNS(ctx context.Context, w dns.ResponseWriter, r *dns.Msg) (int, error) {
 	state := request.Request{W: w, Req: r}
 
-	qname := state.Name()
-	qtype := state.QType()
-	zone := plugin.Zones(c.Zones).Matches(qname)
+	zone := plugin.Zones(c.Zones).Matches(state.Name())
 	if zone == "" {
 		return plugin.NextOrFailure(c.Name(), c.Next, ctx, w, r)
 	}
 
-	do := state.Do() // TODO(): might need more from OPT record? Like the actual bufsize?
-
 	now := c.now().UTC()
 
-	i, ttl := c.get(now, qname, qtype, do)
+	server := metrics.WithServer(ctx)
+
+	i, ttl := c.get(now, state, server)
 	if i != nil && ttl > 0 {
 		resp := i.toMsg(r, now)
 
@@ -42,14 +41,16 @@ func (c *Cache) ServeDNS(ctx context.Context, w dns.ResponseWriter, r *dns.Msg)
 			threshold := int(math.Ceil(float64(c.percentage) / 100 * float64(i.origTTL)))
 			if i.Freq.Hits() >= c.prefetch && ttl <= threshold {
 				go func() {
-					cachePrefetches.Inc()
+					cachePrefetches.WithLabelValues(server).Inc()
 					// When prefetching we loose the item i, and with it the frequency
 					// that we've gathered sofar. See we copy the frequencies info back
 					// into the new item that was stored in the cache.
-					prr := &ResponseWriter{ResponseWriter: w, Cache: c, prefetch: true, state: state}
+					prr := &ResponseWriter{ResponseWriter: w, Cache: c,
+						prefetch: true, state: state,
+						server: server}
 					plugin.NextOrFailure(c.Name(), c.Next, ctx, prr, r)
 
-					if i1 := c.exists(qname, qtype, do); i1 != nil {
+					if i1 := c.exists(state); i1 != nil {
 						i1.Freq.Reset(now, i.Freq.Hits())
 					}
 				}()
@@ -58,31 +59,31 @@ func (c *Cache) ServeDNS(ctx context.Context, w dns.ResponseWriter, r *dns.Msg)
 		return dns.RcodeSuccess, nil
 	}
 
-	crr := &ResponseWriter{ResponseWriter: w, Cache: c, state: state}
+	crr := &ResponseWriter{ResponseWriter: w, Cache: c, state: state, server: server}
 	return plugin.NextOrFailure(c.Name(), c.Next, ctx, crr, r)
 }
 
 // Name implements the Handler interface.
 func (c *Cache) Name() string { return "cache" }
 
-func (c *Cache) get(now time.Time, qname string, qtype uint16, do bool) (*item, int) {
-	k := hash(qname, qtype, do)
+func (c *Cache) get(now time.Time, state request.Request, server string) (*item, int) {
+	k := hash(state.Name(), state.QType(), state.Do())
 
 	if i, ok := c.ncache.Get(k); ok {
-		cacheHits.WithLabelValues(Denial).Inc()
+		cacheHits.WithLabelValues(server, Denial).Inc()
 		return i.(*item), i.(*item).ttl(now)
 	}
 
 	if i, ok := c.pcache.Get(k); ok {
-		cacheHits.WithLabelValues(Success).Inc()
+		cacheHits.WithLabelValues(server, Success).Inc()
 		return i.(*item), i.(*item).ttl(now)
 	}
-	cacheMisses.Inc()
+	cacheMisses.WithLabelValues(server).Inc()
 	return nil, 0
 }
 
-func (c *Cache) exists(qname string, qtype uint16, do bool) *item {
-	k := hash(qname, qtype, do)
+func (c *Cache) exists(state request.Request) *item {
+	k := hash(state.Name(), state.QType(), state.Do())
 	if i, ok := c.ncache.Get(k); ok {
 		return i.(*item)
 	}
@@ -98,42 +99,35 @@ var (
 		Subsystem: "cache",
 		Name:      "size",
 		Help:      "The number of elements in the cache.",
-	}, []string{"type"})
-
-	cacheCapacity = prometheus.NewGaugeVec(prometheus.GaugeOpts{
-		Namespace: plugin.Namespace,
-		Subsystem: "cache",
-		Name:      "capacity",
-		Help:      "The cache's capacity.",
-	}, []string{"type"})
+	}, []string{"server", "type"})
 
 	cacheHits = prometheus.NewCounterVec(prometheus.CounterOpts{
 		Namespace: plugin.Namespace,
 		Subsystem: "cache",
 		Name:      "hits_total",
 		Help:      "The count of cache hits.",
-	}, []string{"type"})
+	}, []string{"server", "type"})
 
-	cacheMisses = prometheus.NewCounter(prometheus.CounterOpts{
+	cacheMisses = prometheus.NewCounterVec(prometheus.CounterOpts{
 		Namespace: plugin.Namespace,
 		Subsystem: "cache",
 		Name:      "misses_total",
 		Help:      "The count of cache misses.",
-	})
+	}, []string{"server"})
 
-	cachePrefetches = prometheus.NewCounter(prometheus.CounterOpts{
+	cachePrefetches = prometheus.NewCounterVec(prometheus.CounterOpts{
 		Namespace: plugin.Namespace,
 		Subsystem: "cache",
 		Name:      "prefetch_total",
 		Help:      "The number of time the cache has prefetched a cached item.",
-	})
+	}, []string{"server"})
 
-	cacheDrops = prometheus.NewCounter(prometheus.CounterOpts{
+	cacheDrops = prometheus.NewCounterVec(prometheus.CounterOpts{
 		Namespace: plugin.Namespace,
 		Subsystem: "cache",
 		Name:      "drops_total",
 		Help:      "The number responses that are not cached, because the reply is malformed.",
-	})
+	}, []string{"server"})
 )
 
 var once sync.Once