222 lines
5.9 KiB
Go
222 lines
5.9 KiB
Go
package unbound
|
|
|
|
import (
|
|
"bufio"
|
|
"bytes"
|
|
"context"
|
|
"fmt"
|
|
"net"
|
|
"os/exec"
|
|
"strconv"
|
|
"strings"
|
|
"time"
|
|
|
|
"github.com/influxdata/telegraf"
|
|
"github.com/influxdata/telegraf/filter"
|
|
"github.com/influxdata/telegraf/internal"
|
|
"github.com/influxdata/telegraf/plugins/inputs"
|
|
)
|
|
|
|
type runner func(cmdName string, Timeout internal.Duration, UseSudo bool, Server string, ThreadAsTag bool, ConfigFile string) (*bytes.Buffer, error)
|
|
|
|
// Unbound is used to store configuration values
|
|
type Unbound struct {
|
|
Binary string
|
|
Timeout internal.Duration
|
|
UseSudo bool
|
|
Server string
|
|
ThreadAsTag bool
|
|
ConfigFile string
|
|
|
|
filter filter.Filter
|
|
run runner
|
|
}
|
|
|
|
var defaultBinary = "/usr/sbin/unbound-control"
|
|
var defaultTimeout = internal.Duration{Duration: time.Second}
|
|
|
|
var sampleConfig = `
|
|
## Address of server to connect to, read from unbound conf default, optionally ':port'
|
|
## Will lookup IP if given a hostname
|
|
server = "127.0.0.1:8953"
|
|
|
|
## If running as a restricted user you can prepend sudo for additional access:
|
|
# use_sudo = false
|
|
|
|
## The default location of the unbound-control binary can be overridden with:
|
|
# binary = "/usr/sbin/unbound-control"
|
|
|
|
## The default location of the unbound config file can be overridden with:
|
|
# config_file = "/etc/unbound/unbound.conf"
|
|
|
|
## The default timeout of 1s can be overridden with:
|
|
# timeout = "1s"
|
|
|
|
## When set to true, thread metrics are tagged with the thread id.
|
|
##
|
|
## The default is false for backwards compatibility, and will be changed to
|
|
## true in a future version. It is recommended to set to true on new
|
|
## deployments.
|
|
thread_as_tag = false
|
|
`
|
|
|
|
// Description displays what this plugin is about
|
|
func (s *Unbound) Description() string {
|
|
return "A plugin to collect stats from the Unbound DNS resolver"
|
|
}
|
|
|
|
// SampleConfig displays configuration instructions
|
|
func (s *Unbound) SampleConfig() string {
|
|
return sampleConfig
|
|
}
|
|
|
|
// Shell out to unbound_stat and return the output
|
|
func unboundRunner(cmdName string, Timeout internal.Duration, UseSudo bool, Server string, ThreadAsTag bool, ConfigFile string) (*bytes.Buffer, error) {
|
|
cmdArgs := []string{"stats_noreset"}
|
|
|
|
if Server != "" {
|
|
host, port, err := net.SplitHostPort(Server)
|
|
if err != nil { // No port was specified
|
|
host = Server
|
|
port = ""
|
|
}
|
|
|
|
// Unbound control requires an IP address, and we want to be nice to the user
|
|
resolver := net.Resolver{}
|
|
ctx, lookUpCancel := context.WithTimeout(context.Background(), Timeout.Duration)
|
|
defer lookUpCancel()
|
|
serverIps, err := resolver.LookupIPAddr(ctx, host)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("error looking up ip for server: %s: %s", Server, err)
|
|
}
|
|
if len(serverIps) == 0 {
|
|
return nil, fmt.Errorf("error no ip for server: %s: %s", Server, err)
|
|
}
|
|
server := serverIps[0].IP.String()
|
|
if port != "" {
|
|
server = server + "@" + port
|
|
}
|
|
|
|
cmdArgs = append([]string{"-s", server}, cmdArgs...)
|
|
}
|
|
|
|
if ConfigFile != "" {
|
|
cmdArgs = append([]string{"-c", ConfigFile}, cmdArgs...)
|
|
}
|
|
|
|
cmd := exec.Command(cmdName, cmdArgs...)
|
|
|
|
if UseSudo {
|
|
cmdArgs = append([]string{cmdName}, cmdArgs...)
|
|
cmd = exec.Command("sudo", cmdArgs...)
|
|
}
|
|
|
|
var out bytes.Buffer
|
|
cmd.Stdout = &out
|
|
err := internal.RunTimeout(cmd, Timeout.Duration)
|
|
if err != nil {
|
|
return &out, fmt.Errorf("error running unbound-control: %s (%s %v)", err, cmdName, cmdArgs)
|
|
}
|
|
|
|
return &out, nil
|
|
}
|
|
|
|
// Gather collects stats from unbound-control and adds them to the Accumulator
|
|
//
|
|
// All the dots in stat name will replaced by underscores. Histogram statistics will not be collected.
|
|
func (s *Unbound) Gather(acc telegraf.Accumulator) error {
|
|
|
|
// Always exclude histogram statistics
|
|
statExcluded := []string{"histogram.*"}
|
|
filterExcluded, err := filter.Compile(statExcluded)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
out, err := s.run(s.Binary, s.Timeout, s.UseSudo, s.Server, s.ThreadAsTag, s.ConfigFile)
|
|
if err != nil {
|
|
return fmt.Errorf("error gathering metrics: %s", err)
|
|
}
|
|
|
|
// Process values
|
|
fields := make(map[string]interface{})
|
|
fieldsThreads := make(map[string]map[string]interface{})
|
|
|
|
scanner := bufio.NewScanner(out)
|
|
for scanner.Scan() {
|
|
|
|
cols := strings.Split(scanner.Text(), "=")
|
|
|
|
// Check split correctness
|
|
if len(cols) != 2 {
|
|
continue
|
|
}
|
|
|
|
stat := cols[0]
|
|
value := cols[1]
|
|
|
|
// Filter value
|
|
if filterExcluded.Match(stat) {
|
|
continue
|
|
}
|
|
|
|
fieldValue, err := strconv.ParseFloat(value, 64)
|
|
if err != nil {
|
|
acc.AddError(fmt.Errorf("Expected a numerical value for %s = %v",
|
|
stat, value))
|
|
continue
|
|
}
|
|
|
|
// is this a thread related value?
|
|
if s.ThreadAsTag && strings.HasPrefix(stat, "thread") {
|
|
// split the stat
|
|
statTokens := strings.Split(stat, ".")
|
|
// make sure we split something
|
|
if len(statTokens) > 1 {
|
|
// set the thread identifier
|
|
threadID := strings.TrimPrefix(statTokens[0], "thread")
|
|
// make sure we have a proper thread ID
|
|
if _, err = strconv.Atoi(threadID); err == nil {
|
|
// create new slice without the thread identifier (skip first token)
|
|
threadTokens := statTokens[1:]
|
|
// re-define stat
|
|
field := strings.Join(threadTokens[:], "_")
|
|
if fieldsThreads[threadID] == nil {
|
|
fieldsThreads[threadID] = make(map[string]interface{})
|
|
}
|
|
fieldsThreads[threadID][field] = fieldValue
|
|
}
|
|
}
|
|
} else {
|
|
field := strings.Replace(stat, ".", "_", -1)
|
|
fields[field] = fieldValue
|
|
}
|
|
|
|
}
|
|
|
|
acc.AddFields("unbound", fields, nil)
|
|
|
|
if s.ThreadAsTag && len(fieldsThreads) > 0 {
|
|
for thisThreadID, thisThreadFields := range fieldsThreads {
|
|
thisThreadTag := map[string]string{"thread": thisThreadID}
|
|
acc.AddFields("unbound_threads", thisThreadFields, thisThreadTag)
|
|
}
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func init() {
|
|
inputs.Add("unbound", func() telegraf.Input {
|
|
return &Unbound{
|
|
run: unboundRunner,
|
|
Binary: defaultBinary,
|
|
Timeout: defaultTimeout,
|
|
UseSudo: false,
|
|
Server: "",
|
|
ThreadAsTag: false,
|
|
ConfigFile: "",
|
|
}
|
|
})
|
|
}
|