dns_query plugin fixups:

- renamed plugin to dns_query
- domains are optional
- new record types

closes #694

plugins/inputs/dns_query/README.md

@@ -0,0 +1,51 @@
+# DNS Query Input Plugin
+
+The DNS plugin gathers dns query times in miliseconds - like [Dig](https://en.wikipedia.org/wiki/Dig_\(command\))
+
+### Configuration:
+
+```
+# Sample Config:
+[[inputs.dns_query]]
+  ## servers to query
+  servers = ["8.8.8.8"] # required
+
+  ## Domains or subdomains to query. "." (root) is default
+  domains = ["."] # optional
+
+  ## Query record type. Posible values: A, AAAA, ANY, CNAME, MX,  NS, PTR, SOA, SPF, SRV, TXT. Default is "NS"
+  record_type = "A" # optional
+
+  ## Dns server port. 53 is default
+  port = 53 # optional
+
+  ## Query timeout in seconds. Default is 2 seconds
+  timeout = 2 # optional
+```
+
+For querying more than one record type make:
+
+```
+[[inputs.dns_query]]
+  domains = ["mjasion.pl"]
+  servers = ["8.8.8.8", "8.8.4.4"]
+  record_type = "A"
+
+[[inputs.dns_query]]
+  domains = ["mjasion.pl"]
+  servers = ["8.8.8.8", "8.8.4.4"]
+  record_type = "MX"
+```
+
+### Tags:
+
+- server
+- domain
+- record_type
+
+### Example output:
+
+```
+./telegraf -config telegraf.conf -test -input-filter dns_query -test
+> dns_query,domain=mjasion.pl,record_type=A,server=8.8.8.8 query_time_ms=67.189842 1456082743585760680
+```

plugins/inputs/dns_query/dns_query.go

@@ -0,0 +1,159 @@
+package dns_query
+
+import (
+	"errors"
+	"fmt"
+	"github.com/influxdata/telegraf"
+	"github.com/influxdata/telegraf/plugins/inputs"
+	"github.com/miekg/dns"
+	"net"
+	"strconv"
+	"time"
+)
+
+type DnsQuery struct {
+	// Domains or subdomains to query
+	Domains []string
+
+	// Server to query
+	Servers []string
+
+	// Record type
+	RecordType string `toml:"record_type"`
+
+	// DNS server port number
+	Port int
+
+	// Dns query timeout in seconds. 0 means no timeout
+	Timeout int
+}
+
+var sampleConfig = `
+  ## servers to query
+  servers = ["8.8.8.8"] # required
+
+  ## Domains or subdomains to query. "."(root) is default
+  domains = ["."] # optional
+
+  ## Query record type. Posible values: A, AAAA, CNAME, MX,  NS, PTR, TXT, SOA, SPF, SRV. Default is "NS"
+  record_type = "A" # optional
+
+  ## Dns server port. 53 is default
+  port = 53 # optional
+
+  ## Query timeout in seconds. Default is 2 seconds
+  timeout = 2 # optional
+`
+
+func (d *DnsQuery) SampleConfig() string {
+	return sampleConfig
+}
+
+func (d *DnsQuery) Description() string {
+	return "Query given DNS server and gives statistics"
+}
+func (d *DnsQuery) Gather(acc telegraf.Accumulator) error {
+	d.setDefaultValues()
+	for _, domain := range d.Domains {
+		for _, server := range d.Servers {
+			dnsQueryTime, err := d.getDnsQueryTime(domain, server)
+			if err != nil {
+				return err
+			}
+			tags := map[string]string{
+				"server":      server,
+				"domain":      domain,
+				"record_type": d.RecordType,
+			}
+
+			fields := map[string]interface{}{"query_time_ms": dnsQueryTime}
+			acc.AddFields("dns_query", fields, tags)
+		}
+	}
+
+	return nil
+}
+
+func (d *DnsQuery) setDefaultValues() {
+	if len(d.RecordType) == 0 {
+		d.RecordType = "NS"
+	}
+
+	if len(d.Domains) == 0 {
+		d.Domains = []string{"."}
+		d.RecordType = "NS"
+	}
+
+	if d.Port == 0 {
+		d.Port = 53
+	}
+
+	if d.Timeout == 0 {
+		d.Timeout = 2
+	}
+}
+
+func (d *DnsQuery) getDnsQueryTime(domain string, server string) (float64, error) {
+	dnsQueryTime := float64(0)
+
+	c := new(dns.Client)
+	c.ReadTimeout = time.Duration(d.Timeout) * time.Second
+
+	m := new(dns.Msg)
+	recordType, err := d.parseRecordType()
+	if err != nil {
+		return dnsQueryTime, err
+	}
+	m.SetQuestion(dns.Fqdn(domain), recordType)
+	m.RecursionDesired = true
+
+	r, rtt, err := c.Exchange(m, net.JoinHostPort(server, strconv.Itoa(d.Port)))
+	if err != nil {
+		return dnsQueryTime, err
+	}
+	if r.Rcode != dns.RcodeSuccess {
+		return dnsQueryTime, errors.New(fmt.Sprintf("Invalid answer name %s after %s query for %s\n", domain, d.RecordType, domain))
+	}
+	dnsQueryTime = float64(rtt.Nanoseconds()) / 1e6
+	return dnsQueryTime, nil
+}
+
+func (d *DnsQuery) parseRecordType() (uint16, error) {
+	var recordType uint16
+	var error error
+
+	switch d.RecordType {
+	case "A":
+		recordType = dns.TypeA
+	case "AAAA":
+		recordType = dns.TypeAAAA
+	case "ANY":
+		recordType = dns.TypeANY
+	case "CNAME":
+		recordType = dns.TypeCNAME
+	case "MX":
+		recordType = dns.TypeMX
+	case "NS":
+		recordType = dns.TypeNS
+	case "PTR":
+		recordType = dns.TypePTR
+	case "SOA":
+		recordType = dns.TypeSOA
+	case "SPF":
+		recordType = dns.TypeSPF
+	case "SRV":
+		recordType = dns.TypeSRV
+	case "TXT":
+		recordType = dns.TypeTXT
+	default:
+		error = errors.New(fmt.Sprintf("Record type %s not recognized", d.RecordType))
+	}
+
+	return recordType, error
+}
+
+func init() {
+	inputs.Add("dns_query", func() telegraf.Input {
+		return &DnsQuery{}
+	})
+}

plugins/inputs/dns_query/dns_query_test.go

@@ -0,0 +1,184 @@
+package dns_query
+
+import (
+	"github.com/influxdata/telegraf/testutil"
+	"github.com/miekg/dns"
+	"github.com/stretchr/testify/assert"
+	"testing"
+	"time"
+)
+
+var servers = []string{"8.8.8.8"}
+var domains = []string{"mjasion.pl"}
+
+func TestGathering(t *testing.T) {
+	var dnsConfig = DnsQuery{
+		Servers: servers,
+		Domains: domains,
+	}
+	var acc testutil.Accumulator
+
+	dnsConfig.Gather(&acc)
+	metric, _ := acc.Get("dns_query")
+	queryTime, _ := metric.Fields["query_time_ms"].(float64)
+
+	assert.NotEqual(t, 0, queryTime)
+}
+
+func TestGatheringMxRecord(t *testing.T) {
+	var dnsConfig = DnsQuery{
+		Servers: servers,
+		Domains: domains,
+	}
+	var acc testutil.Accumulator
+	dnsConfig.RecordType = "MX"
+
+	dnsConfig.Gather(&acc)
+	metric, _ := acc.Get("dns_query")
+	queryTime, _ := metric.Fields["query_time_ms"].(float64)
+
+	assert.NotEqual(t, 0, queryTime)
+}
+
+func TestGatheringRootDomain(t *testing.T) {
+	var dnsConfig = DnsQuery{
+		Servers:    servers,
+		Domains:    []string{"."},
+		RecordType: "MX",
+	}
+	var acc testutil.Accumulator
+	tags := map[string]string{
+		"server":      "8.8.8.8",
+		"domain":      ".",
+		"record_type": "MX",
+	}
+	fields := map[string]interface{}{}
+
+	dnsConfig.Gather(&acc)
+	metric, _ := acc.Get("dns_query")
+	queryTime, _ := metric.Fields["query_time_ms"].(float64)
+
+	fields["query_time_ms"] = queryTime
+	acc.AssertContainsTaggedFields(t, "dns_query", fields, tags)
+}
+
+func TestMetricContainsServerAndDomainAndRecordTypeTags(t *testing.T) {
+	var dnsConfig = DnsQuery{
+		Servers: servers,
+		Domains: domains,
+	}
+	var acc testutil.Accumulator
+	tags := map[string]string{
+		"server":      "8.8.8.8",
+		"domain":      "mjasion.pl",
+		"record_type": "NS",
+	}
+	fields := map[string]interface{}{}
+
+	dnsConfig.Gather(&acc)
+	metric, _ := acc.Get("dns_query")
+	queryTime, _ := metric.Fields["query_time_ms"].(float64)
+
+	fields["query_time_ms"] = queryTime
+	acc.AssertContainsTaggedFields(t, "dns_query", fields, tags)
+}
+
+func TestGatheringTimeout(t *testing.T) {
+	var dnsConfig = DnsQuery{
+		Servers: servers,
+		Domains: domains,
+	}
+	var acc testutil.Accumulator
+	dnsConfig.Port = 60054
+	dnsConfig.Timeout = 1
+	var err error
+
+	channel := make(chan error, 1)
+	go func() {
+		channel <- dnsConfig.Gather(&acc)
+	}()
+	select {
+	case res := <-channel:
+		err = res
+	case <-time.After(time.Second * 2):
+		err = nil
+	}
+
+	assert.Error(t, err)
+	assert.Contains(t, err.Error(), "i/o timeout")
+}
+
+func TestSettingDefaultValues(t *testing.T) {
+	dnsConfig := DnsQuery{}
+
+	dnsConfig.setDefaultValues()
+
+	assert.Equal(t, []string{"."}, dnsConfig.Domains, "Default domain not equal \".\"")
+	assert.Equal(t, "NS", dnsConfig.RecordType, "Default record type not equal 'NS'")
+	assert.Equal(t, 53, dnsConfig.Port, "Default port number not equal 53")
+	assert.Equal(t, 2, dnsConfig.Timeout, "Default timeout not equal 2")
+
+	dnsConfig = DnsQuery{Domains: []string{"."}}
+
+	dnsConfig.setDefaultValues()
+
+	assert.Equal(t, "NS", dnsConfig.RecordType, "Default record type not equal 'NS'")
+}
+
+func TestRecordTypeParser(t *testing.T) {
+	var dnsConfig = DnsQuery{}
+	var recordType uint16
+
+	dnsConfig.RecordType = "A"
+	recordType, _ = dnsConfig.parseRecordType()
+	assert.Equal(t, dns.TypeA, recordType)
+
+	dnsConfig.RecordType = "AAAA"
+	recordType, _ = dnsConfig.parseRecordType()
+	assert.Equal(t, dns.TypeAAAA, recordType)
+
+	dnsConfig.RecordType = "ANY"
+	recordType, _ = dnsConfig.parseRecordType()
+	assert.Equal(t, dns.TypeANY, recordType)
+
+	dnsConfig.RecordType = "CNAME"
+	recordType, _ = dnsConfig.parseRecordType()
+	assert.Equal(t, dns.TypeCNAME, recordType)
+
+	dnsConfig.RecordType = "MX"
+	recordType, _ = dnsConfig.parseRecordType()
+	assert.Equal(t, dns.TypeMX, recordType)
+
+	dnsConfig.RecordType = "NS"
+	recordType, _ = dnsConfig.parseRecordType()
+	assert.Equal(t, dns.TypeNS, recordType)
+
+	dnsConfig.RecordType = "PTR"
+	recordType, _ = dnsConfig.parseRecordType()
+	assert.Equal(t, dns.TypePTR, recordType)
+
+	dnsConfig.RecordType = "SOA"
+	recordType, _ = dnsConfig.parseRecordType()
+	assert.Equal(t, dns.TypeSOA, recordType)
+
+	dnsConfig.RecordType = "SPF"
+	recordType, _ = dnsConfig.parseRecordType()
+	assert.Equal(t, dns.TypeSPF, recordType)
+
+	dnsConfig.RecordType = "SRV"
+	recordType, _ = dnsConfig.parseRecordType()
+	assert.Equal(t, dns.TypeSRV, recordType)
+
+	dnsConfig.RecordType = "TXT"
+	recordType, _ = dnsConfig.parseRecordType()
+	assert.Equal(t, dns.TypeTXT, recordType)
+}
+
+func TestRecordTypeParserError(t *testing.T) {
+	var dnsConfig = DnsQuery{}
+	var err error
+
+	dnsConfig.RecordType = "nil"
+	_, err = dnsConfig.parseRecordType()
+	assert.Error(t, err)
+}