plugin/dnstap: some cleanup (#1172)

Some cleanup in proxy and dnstap:
* just use time pkg directly and side step the indirection for Epoch
* Use Set in SetQueryEpoch to be more Go like. (Looked like a reader)
* Don't maintain two sets of time, we already track start, so use that.
* Use time.Time and convert when needed
* dedent the toDnstap function and put in a separate file

plugin/proxy/dnstap.go

@@ -0,0 +1,54 @@
+package proxy
+
+import (
+	"time"
+
+	"github.com/coredns/coredns/plugin/dnstap"
+	"github.com/coredns/coredns/request"
+
+	tap "github.com/dnstap/golang-dnstap"
+	"github.com/miekg/dns"
+	"golang.org/x/net/context"
+)
+
+func toDnstap(ctx context.Context, host string, ex Exchanger, state request.Request, reply *dns.Msg, start time.Time) error {
+	tapper := dnstap.TapperFromContext(ctx)
+	if tapper == nil {
+		return nil
+	}
+
+	// Query
+	b := tapper.TapBuilder()
+	b.TimeSec = uint64(start.Unix())
+	if err := b.HostPort(host); err != nil {
+		return err
+	}
+
+	t := ex.Transport()
+	if t == "" {
+		t = state.Proto()
+	}
+	if t == "tcp" {
+		b.SocketProto = tap.SocketProtocol_TCP
+	} else {
+		b.SocketProto = tap.SocketProtocol_UDP
+	}
+
+	if err := b.Msg(state.Req); err != nil {
+		return err
+	}
+
+	if err := tapper.TapMessage(b.ToOutsideQuery(tap.Message_FORWARDER_QUERY)); err != nil {
+		return err
+	}
+
+	// Response
+	if reply != nil {
+		b.TimeSec = uint64(time.Now().Unix())
+		if err := b.Msg(reply); err != nil {
+			return err
+		}
+		return tapper.TapMessage(b.ToOutsideResponse(tap.Message_FORWARDER_RESPONSE))
+	}
+	return nil
+}

plugin/proxy/dnstap_test.go

@@ -2,6 +2,7 @@ package proxy
 
 import (
 	"testing"
+	"time"
 
 	"github.com/coredns/coredns/plugin/dnstap/msg"
 	"github.com/coredns/coredns/plugin/dnstap/test"
@@ -18,7 +19,7 @@ func testCase(t *testing.T, ex Exchanger, q, r *dns.Msg, datq, datr *msg.Data) {
 	tapr := datr.ToOutsideResponse(tap.Message_FORWARDER_RESPONSE)
 	ctx := test.Context{}
 	err := toDnstap(&ctx, "10.240.0.1:40212", ex,
-		request.Request{W: &mwtest.ResponseWriter{}, Req: q}, r, 0, 0)
+		request.Request{W: &mwtest.ResponseWriter{}, Req: q}, r, time.Now())
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -50,7 +51,7 @@ func TestDnstap(t *testing.T) {
 }
 
 func TestNoDnstap(t *testing.T) {
-	err := toDnstap(context.TODO(), "", nil, request.Request{}, nil, 0, 0)
+	err := toDnstap(context.TODO(), "", nil, request.Request{}, nil, time.Now())
 	if err != nil {
 		t.Fatal(err)
 	}

plugin/proxy/proxy.go

@@ -9,12 +9,9 @@ import (
 	"time"
 
 	"github.com/coredns/coredns/plugin"
-	"github.com/coredns/coredns/plugin/dnstap"
-	"github.com/coredns/coredns/plugin/dnstap/msg"
 	"github.com/coredns/coredns/plugin/pkg/healthcheck"
 	"github.com/coredns/coredns/request"
 
-	tap "github.com/dnstap/golang-dnstap"
 	"github.com/miekg/dns"
 	ot "github.com/opentracing/opentracing-go"
 	"golang.org/x/net/context"
@@ -89,20 +86,18 @@ func (p Proxy) ServeDNS(ctx context.Context, w dns.ResponseWriter, r *dns.Msg) (
 			}
 
 			atomic.AddInt64(&host.Conns, 1)
-			queryEpoch := msg.Epoch()
 
 			RequestCount.WithLabelValues(state.Proto(), upstream.Exchanger().Protocol(), familyToString(state.Family()), host.Name).Add(1)
 
 			reply, backendErr = upstream.Exchanger().Exchange(ctx, host.Name, state)
 
-			respEpoch := msg.Epoch()
 			atomic.AddInt64(&host.Conns, -1)
 
 			if child != nil {
 				child.Finish()
 			}
 
-			taperr := toDnstap(ctx, host.Name, upstream.Exchanger(), state, reply, queryEpoch, respEpoch)
+			taperr := toDnstap(ctx, host.Name, upstream.Exchanger(), state, reply, start)
 
 			if backendErr == nil {
 				w.WriteMsg(reply)
@@ -172,43 +167,6 @@ func (p Proxy) match(state request.Request) (u Upstream) {
 // Name implements the Handler interface.
 func (p Proxy) Name() string { return "proxy" }
 
-func toDnstap(ctx context.Context, host string, ex Exchanger, state request.Request, reply *dns.Msg, queryEpoch, respEpoch uint64) (err error) {
-	if tapper := dnstap.TapperFromContext(ctx); tapper != nil {
-		// Query
-		b := tapper.TapBuilder()
-		b.TimeSec = queryEpoch
-		if err = b.HostPort(host); err != nil {
-			return
-		}
-		t := ex.Transport()
-		if t == "" {
-			t = state.Proto()
-		}
-		if t == "tcp" {
-			b.SocketProto = tap.SocketProtocol_TCP
-		} else {
-			b.SocketProto = tap.SocketProtocol_UDP
-		}
-		if err = b.Msg(state.Req); err != nil {
-			return
-		}
-		err = tapper.TapMessage(b.ToOutsideQuery(tap.Message_FORWARDER_QUERY))
-		if err != nil {
-			return
-		}
-
-		// Response
-		if reply != nil {
-			b.TimeSec = respEpoch
-			if err = b.Msg(reply); err != nil {
-				return
-			}
-			err = tapper.TapMessage(b.ToOutsideResponse(tap.Message_FORWARDER_RESPONSE))
-		}
-	}
-	return
-}
-
 const (
 	defaultFailTimeout = 2 * time.Second
 	defaultTimeout     = 5 * time.Second