Merge branch 'master' into kb-procstat-x

in this commit:

- centralize logging output handler.
- set global Info/Debug/Error log levels based on config file or flags.
- remove per-plugin debug arg handling.
- add a I!, D!, or E! to every log message.
- add configuration option to specify where to send logs.

closes #1786

CHANGELOG.md

@@ -1,10 +1,10 @@
-## v1.0 [unreleased]
 ## v1.1 [unreleased]
 
 ### Release Notes
 
 ### Features
 
+- [#1782](https://github.com/influxdata/telegraf/pull/1782): Allow numeric and non-string values for tag_keys.
 - [#1694](https://github.com/influxdata/telegraf/pull/1694): Adding Gauge and Counter metric types.
 - [#1606](https://github.com/influxdata/telegraf/pull/1606): Remove carraige returns from exec plugin output on Windows
 - [#1674](https://github.com/influxdata/telegraf/issues/1674): elasticsearch input: configurable timeout.
@@ -20,15 +20,30 @@
 - [#1697](https://github.com/influxdata/telegraf/pull/1697): Add NATS output plugin.
 - [#1407](https://github.com/influxdata/telegraf/pull/1407): HTTP service listener input plugin.
 - [#1699](https://github.com/influxdata/telegraf/pull/1699): Add database blacklist option for Postgresql
+- [#1791](https://github.com/influxdata/telegraf/pull/1791): Add Docker container state metrics to Docker input plugin output
+- [#1755](https://github.com/influxdata/telegraf/issues/1755): Add support to SNMP for IP & MAC address conversion.
+- [#1729](https://github.com/influxdata/telegraf/issues/1729): Add support to SNMP for OID index suffixes.
+- [#1813](https://github.com/influxdata/telegraf/pull/1813): Change default arguments for SNMP plugin.
+- [#1686](https://github.com/influxdata/telegraf/pull/1686): Mesos input plugin: very high-cardinality mesos-task metrics removed.
+- [#1839](https://github.com/influxdata/telegraf/pull/1839): Exact match with pgrep -x option in procstat
+- [#1838](https://github.com/influxdata/telegraf/pull/1838): Logging overhaul to centralize the logger & log levels, & provide a logfile config option.
 
 ### Bugfixes
 
+- [#1746](https://github.com/influxdata/telegraf/issues/1746): Fix handling of non-string values for JSON keys listed in tag_keys.
 - [#1628](https://github.com/influxdata/telegraf/issues/1628): Fix mongodb input panic on version 2.2.
-- [#1738](https://github.com/influxdata/telegraf/issues/1738): Fix unmarshal of influxdb metrics with null tags
 - [#1733](https://github.com/influxdata/telegraf/issues/1733): Fix statsd scientific notation parsing
 - [#1716](https://github.com/influxdata/telegraf/issues/1716): Sensors plugin strconv.ParseFloat: parsing "": invalid syntax
 - [#1530](https://github.com/influxdata/telegraf/issues/1530): Fix prometheus_client reload panic
 - [#1764](https://github.com/influxdata/telegraf/issues/1764): Fix kafka consumer panic when nil error is returned down errs channel.
+- [#1768](https://github.com/influxdata/telegraf/pull/1768): Speed up statsd parsing.
+- [#1751](https://github.com/influxdata/telegraf/issues/1751): Fix powerdns integer parse error handling.
+- [#1752](https://github.com/influxdata/telegraf/issues/1752): Fix varnish plugin defaults not being used.
+- [#1517](https://github.com/influxdata/telegraf/issues/1517): Fix windows glob paths.
+- [#1137](https://github.com/influxdata/telegraf/issues/1137): Fix issue loading config directory on windows.
+- [#1772](https://github.com/influxdata/telegraf/pull/1772): Windows remote management interactive service fix.
+- [#1702](https://github.com/influxdata/telegraf/issues/1702): sqlserver, fix issue when case sensitive collation is activated.
+- [#1823](https://github.com/influxdata/telegraf/issues/1823): Fix huge allocations in http_listener when dealing with huge payloads.
 
 ## v1.0.1 [unreleased]
 
@@ -37,6 +52,7 @@
 - [#1775](https://github.com/influxdata/telegraf/issues/1775): Prometheus output: Fix bug with multi-batch writes.
 - [#1738](https://github.com/influxdata/telegraf/issues/1738): Fix unmarshal of influxdb metrics with null tags.
 - [#1773](https://github.com/influxdata/telegraf/issues/1773): Add configurable timeout to influxdb input plugin.
+- [#1785](https://github.com/influxdata/telegraf/pull/1785): Fix statsd no default value panic.
 
 ## v1.0 [2016-09-08]
 
@@ -45,15 +61,11 @@
 **Breaking Change** The SNMP plugin is being deprecated in it's current form.
 There is a [new SNMP plugin](https://github.com/influxdata/telegraf/tree/master/plugins/inputs/snmp)
 which fixes many of the issues and confusions
-of it's predecessor. For users wanting to continue to use the deprecated SNMP
+of its predecessor. For users wanting to continue to use the deprecated SNMP
 plugin, you will need to change your config file from `[[inputs.snmp]]` to
 `[[inputs.snmp_legacy]]`. The configuration of the new SNMP plugin is _not_
 backwards-compatible.
 
-- Telegraf now supports being installed as an official windows service,
-which can be installed via
-`> C:\Program Files\Telegraf\telegraf.exe --service install`
-
 **Breaking Change**: Aerospike main server node measurements have been renamed
 aerospike_node. Aerospike namespace measurements have been renamed to
 aerospike_namespace. They will also now be tagged with the node_name
@@ -84,6 +96,10 @@ should now look like:
     path = "/"
 ```
 
+- Telegraf now supports being installed as an official windows service,
+which can be installed via
+`> C:\Program Files\Telegraf\telegraf.exe --service install`
+
 - `flush_jitter` behavior has been changed. The random jitter will now be
 evaluated at every flush interval, rather than once at startup. This makes it
 consistent with the behavior of `collection_jitter`.
@@ -180,6 +196,7 @@ consistent with the behavior of `collection_jitter`.
 - [#1425](https://github.com/influxdata/telegraf/issues/1425): Fix win_perf_counter "index out of range" panic.
 - [#1634](https://github.com/influxdata/telegraf/issues/1634): Fix ntpq panic when field is missing.
 - [#1637](https://github.com/influxdata/telegraf/issues/1637): Sanitize graphite output field names.
+- [#1695](https://github.com/influxdata/telegraf/pull/1695): Fix MySQL plugin not sending 0 value fields.
 
 ## v0.13.1 [2016-05-24]
 

CONTRIBUTING.md

@@ -32,7 +32,7 @@ Assuming you can already build the project, run these in the telegraf directory:
 
 1. `go get github.com/sparrc/gdm`
 1. `gdm restore`
-1. `gdm save`
+1. `GOOS=linux gdm save`
 
 ## Input Plugins
 
@@ -84,9 +84,9 @@ func (s *Simple) SampleConfig() string {
 
 func (s *Simple) Gather(acc telegraf.Accumulator) error {
     if s.Ok {
-        acc.Add("state", "pretty good", nil)
+        acc.AddFields("state", map[string]interface{}{"value": "pretty good"}, nil)
     } else {
-        acc.Add("state", "not great", nil)
+        acc.AddFields("state", map[string]interface{}{"value": "not great"}, nil)
     }
 
     return nil
@@ -97,6 +97,13 @@ func init() {
 }
 ```
 
+## Adding Typed Metrics
+
+In addition the the `AddFields` function, the accumulator also supports an
+`AddGauge` and `AddCounter` function. These functions are for adding _typed_
+metrics. Metric types are ignored for the InfluxDB output, but can be used
+for other outputs, such as [prometheus](https://prometheus.io/docs/concepts/metric_types/).
+
 ## Input Plugins Accepting Arbitrary Data Formats
 
 Some input plugins (such as

Godeps

@@ -1,6 +1,6 @@
 github.com/Shopify/sarama 8aadb476e66ca998f2f6bb3c993e9a2daa3666b9
 github.com/Sirupsen/logrus 219c8cb75c258c552e999735be6df753ffc7afdc
-github.com/aerospike/aerospike-client-go 45863b7fd8640dc12f7fdd397104d97e1986f25a
+github.com/aerospike/aerospike-client-go 7f3a312c3b2a60ac083ec6da296091c52c795c63
 github.com/amir/raidman 53c1b967405155bfc8758557863bf2e14f814687
 github.com/aws/aws-sdk-go 13a12060f716145019378a10e2806c174356b857
 github.com/beorn7/perks 3ac7bf7a47d159a033b107610db8a1b6575507a4
@@ -29,6 +29,7 @@ github.com/hpcloud/tail b2940955ab8b26e19d43a43c4da0475dd81bdb56
 github.com/influxdata/config b79f6829346b8d6e78ba73544b1e1038f1f1c9da
 github.com/influxdata/influxdb e094138084855d444195b252314dfee9eae34cab
 github.com/influxdata/toml af4df43894b16e3fd2b788d01bd27ad0776ef2d0
+github.com/influxdata/wlog 7c63b0a71ef8300adc255344d275e10e5c3a71ec
 github.com/kardianos/osext 29ae4ffbc9a6fe9fb2bc5029050ce6996ea1d3bc
 github.com/kardianos/service 5e335590050d6d00f3aa270217d288dda1c94d0a
 github.com/klauspost/crc32 19b0b332c9e4516a6370a0456e6182c3b5036720
@@ -37,8 +38,8 @@ github.com/matttproud/golang_protobuf_extensions d0c3fe89de86839aecf2e0579c40ba3
 github.com/miekg/dns cce6c130cdb92c752850880fd285bea1d64439dd
 github.com/mreiferson/go-snappystream 028eae7ab5c4c9e2d1cb4c4ca1e53259bbe7e504
 github.com/naoina/go-stringutil 6b638e95a32d0c1131db0e7fe83775cbea4a0d0b
-github.com/nats-io/nats b13fc9d12b0b123ebc374e6b808c6228ae4234a3
-github.com/nats-io/nuid 4f84f5f3b2786224e336af2e13dba0a0a80b76fa
+github.com/nats-io/nats ea8b4fd12ebb823073c0004b9f09ac8748f4f165
+github.com/nats-io/nuid a5152d67cf63cbfb5d992a395458722a45194715
 github.com/nsqio/go-nsq 0b80d6f05e15ca1930e0c5e1d540ed627e299980
 github.com/opencontainers/runc 89ab7f2ccc1e45ddf6485eaa802c35dcf321dfc8
 github.com/prometheus/client_golang 18acf9993a863f4c4b40612e19cdd243e7c86831
@@ -48,7 +49,6 @@ github.com/prometheus/procfs 406e5b7bfd8201a36e2bb5f7bdae0b03380c2ce8
 github.com/samuel/go-zookeeper 218e9c81c0dd8b3b18172b2bbfad92cc7d6db55f
 github.com/shirou/gopsutil 4d0c402af66c78735c5ccf820dc2ca7de5e4ff08
 github.com/soniah/gosnmp eb32571c2410868d85849ad67d1e51d01273eb84
-github.com/sparrc/aerospike-client-go d4bb42d2c2d39dae68e054116f4538af189e05d5
 github.com/streadway/amqp b4f3ceab0337f013208d31348b578d83c0064744
 github.com/stretchr/testify 1f4a1643a57e798696635ea4c126e9127adb7d3c
 github.com/vjeantet/grok 83bfdfdfd1a8146795b28e547a8e3c8b28a466c2

Makefile

@@ -1,4 +1,6 @@
 VERSION := $(shell sh -c 'git describe --always --tags')
+BRANCH := $(shell sh -c 'git rev-parse --abbrev-ref HEAD')
+COMMIT := $(shell sh -c 'git rev-parse HEAD')
 ifdef GOBIN
 PATH := $(GOBIN):$(PATH)
 else
@@ -13,17 +15,18 @@ windows: prepare-windows build-windows
 
 # Only run the build (no dependency grabbing)
 build:
-	go install -ldflags "-X main.version=$(VERSION)" ./...
+	go install -ldflags \
+		"-X main.version=$(VERSION) -X main.commit=$(COMMIT) -X main.branch=$(BRANCH)" ./...
 
 build-windows:
 	GOOS=windows GOARCH=amd64 go build -o telegraf.exe -ldflags \
-		"-X main.version=$(VERSION)" \
+		"-X main.version=$(VERSION) -X main.commit=$(COMMIT) -X main.branch=$(BRANCH)" \
 		./cmd/telegraf/telegraf.go
 
 build-for-docker:
 	CGO_ENABLED=0 GOOS=linux go build -installsuffix cgo -o telegraf -ldflags \
-					"-s -X main.version=$(VERSION)" \
-					./cmd/telegraf/telegraf.go
+		"-s -X main.version=$(VERSION) -X main.commit=$(COMMIT) -X main.branch=$(BRANCH)" \
+		./cmd/telegraf/telegraf.go
 
 # run package script
 package:
@@ -42,6 +45,7 @@ prepare-windows:
 
 # Run all docker containers necessary for unit tests
 docker-run:
+	docker run --name aerospike -p "3000:3000" -d aerospike/aerospike-server:3.9.0
 	docker run --name kafka \
 		-e ADVERTISED_HOST=localhost \
 		-e ADVERTISED_PORT=9092 \
@@ -52,29 +56,28 @@ docker-run:
 	docker run --name postgres -p "5432:5432" -d postgres
 	docker run --name rabbitmq -p "15672:15672" -p "5672:5672" -d rabbitmq:3-management
 	docker run --name redis -p "6379:6379" -d redis
-	docker run --name aerospike -p "3000:3000" -d aerospike/aerospike-server
 	docker run --name nsq -p "4150:4150" -d nsqio/nsq /nsqd
 	docker run --name mqtt -p "1883:1883" -d ncarlier/mqtt
 	docker run --name riemann -p "5555:5555" -d blalor/riemann
-	docker run --name snmp -p "31161:31161/udp" -d titilambert/snmpsim
+	docker run --name nats -p "4222:4222" -d nats
 
 # Run docker containers necessary for CircleCI unit tests
 docker-run-circle:
+	docker run --name aerospike -p "3000:3000" -d aerospike/aerospike-server:3.9.0
 	docker run --name kafka \
 		-e ADVERTISED_HOST=localhost \
 		-e ADVERTISED_PORT=9092 \
 		-p "2181:2181" -p "9092:9092" \
 		-d spotify/kafka
-	docker run --name aerospike -p "3000:3000" -d aerospike/aerospike-server
 	docker run --name nsq -p "4150:4150" -d nsqio/nsq /nsqd
 	docker run --name mqtt -p "1883:1883" -d ncarlier/mqtt
 	docker run --name riemann -p "5555:5555" -d blalor/riemann
-	docker run --name snmp -p "31161:31161/udp" -d titilambert/snmpsim
+	docker run --name nats -p "4222:4222" -d nats
 
 # Kill all docker containers, ignore errors
 docker-kill:
-	-docker kill nsq aerospike redis rabbitmq postgres memcached mysql kafka mqtt riemann snmp
-	-docker rm nsq aerospike redis rabbitmq postgres memcached mysql kafka mqtt riemann snmp
+	-docker kill nsq aerospike redis rabbitmq postgres memcached mysql kafka mqtt riemann nats
+	-docker rm nsq aerospike redis rabbitmq postgres memcached mysql kafka mqtt riemann nats
 
 # Run full unit tests using docker containers (includes setup and teardown)
 test: vet docker-kill docker-run

README.md

@@ -20,12 +20,12 @@ new plugins.
 ### Linux deb and rpm Packages:
 
 Latest:
-* https://dl.influxdata.com/telegraf/releases/telegraf_1.0.0-beta3_amd64.deb
-* https://dl.influxdata.com/telegraf/releases/telegraf-1.0.0_beta3.x86_64.rpm
+* https://dl.influxdata.com/telegraf/releases/telegraf_1.0.0_amd64.deb
+* https://dl.influxdata.com/telegraf/releases/telegraf-1.0.0.x86_64.rpm
 
 Latest (arm):
-* https://dl.influxdata.com/telegraf/releases/telegraf_1.0.0-beta3_armhf.deb
-* https://dl.influxdata.com/telegraf/releases/telegraf-1.0.0_beta3.armhf.rpm
+* https://dl.influxdata.com/telegraf/releases/telegraf_1.0.0_armhf.deb
+* https://dl.influxdata.com/telegraf/releases/telegraf-1.0.0.armhf.rpm
 
 ##### Package Instructions:
 
@@ -46,14 +46,14 @@ to use this repo to install & update telegraf.
 ### Linux tarballs:
 
 Latest:
-* https://dl.influxdata.com/telegraf/releases/telegraf-1.0.0-beta3_linux_amd64.tar.gz
-* https://dl.influxdata.com/telegraf/releases/telegraf-1.0.0-beta3_linux_i386.tar.gz
-* https://dl.influxdata.com/telegraf/releases/telegraf-1.0.0-beta3_linux_armhf.tar.gz
+* https://dl.influxdata.com/telegraf/releases/telegraf-1.0.0_linux_amd64.tar.gz
+* https://dl.influxdata.com/telegraf/releases/telegraf-1.0.0_linux_i386.tar.gz
+* https://dl.influxdata.com/telegraf/releases/telegraf-1.0.0_linux_armhf.tar.gz
 
 ### FreeBSD tarball:
 
 Latest:
-* https://dl.influxdata.com/telegraf/releases/telegraf-1.0.0-beta3_freebsd_amd64.tar.gz
+* https://dl.influxdata.com/telegraf/releases/telegraf-1.0.0_freebsd_amd64.tar.gz
 
 ### Ansible Role:
 
@@ -69,7 +69,7 @@ brew install telegraf
 ### Windows Binaries (EXPERIMENTAL)
 
 Latest:
-* https://dl.influxdata.com/telegraf/releases/telegraf-1.0.0-beta3_windows_amd64.zip
+* https://dl.influxdata.com/telegraf/releases/telegraf-1.0.0_windows_amd64.zip
 
 ### From Source:
 
@@ -161,6 +161,7 @@ Currently implemented sources:
 * [httpjson](https://github.com/influxdata/telegraf/tree/master/plugins/inputs/httpjson) (generic JSON-emitting http service plugin)
 * [influxdb](https://github.com/influxdata/telegraf/tree/master/plugins/inputs/influxdb)
 * [ipmi_sensor](https://github.com/influxdata/telegraf/tree/master/plugins/inputs/ipmi_sensor)
+* [iptables](https://github.com/influxdata/telegraf/tree/master/plugins/inputs/iptables)
 * [jolokia](https://github.com/influxdata/telegraf/tree/master/plugins/inputs/jolokia)
 * [leofs](https://github.com/influxdata/telegraf/tree/master/plugins/inputs/leofs)
 * [lustre2](https://github.com/influxdata/telegraf/tree/master/plugins/inputs/lustre2)
@@ -212,18 +213,21 @@ Currently implemented sources:
 
 Telegraf can also collect metrics via the following service plugins:
 
+* [http_listener](https://github.com/influxdata/telegraf/tree/master/plugins/inputs/http_listener)
+* [kafka_consumer](https://github.com/influxdata/telegraf/tree/master/plugins/inputs/kafka_consumer)
+* [mqtt_consumer](https://github.com/influxdata/telegraf/tree/master/plugins/inputs/mqtt_consumer)
+* [nats_consumer](https://github.com/influxdata/telegraf/tree/master/plugins/inputs/nats_consumer)
+* [nsq_consumer](https://github.com/influxdata/telegraf/tree/master/plugins/inputs/nsq_consumer)
+* [logparser](https://github.com/influxdata/telegraf/tree/master/plugins/inputs/logparser)
 * [statsd](https://github.com/influxdata/telegraf/tree/master/plugins/inputs/statsd)
 * [tail](https://github.com/influxdata/telegraf/tree/master/plugins/inputs/tail)
-* [udp_listener](https://github.com/influxdata/telegraf/tree/master/plugins/inputs/udp_listener)
 * [tcp_listener](https://github.com/influxdata/telegraf/tree/master/plugins/inputs/tcp_listener)
-* [mqtt_consumer](https://github.com/influxdata/telegraf/tree/master/plugins/inputs/mqtt_consumer)
-* [kafka_consumer](https://github.com/influxdata/telegraf/tree/master/plugins/inputs/kafka_consumer)
-* [nats_consumer](https://github.com/influxdata/telegraf/tree/master/plugins/inputs/nats_consumer)
+* [udp_listener](https://github.com/influxdata/telegraf/tree/master/plugins/inputs/udp_listener)
 * [webhooks](https://github.com/influxdata/telegraf/tree/master/plugins/inputs/webhooks)
+  * [filestack](https://github.com/influxdata/telegraf/tree/master/plugins/inputs/webhooks/filestack)
   * [github](https://github.com/influxdata/telegraf/tree/master/plugins/inputs/webhooks/github)
   * [mandrill](https://github.com/influxdata/telegraf/tree/master/plugins/inputs/webhooks/mandrill)
   * [rollbar](https://github.com/influxdata/telegraf/tree/master/plugins/inputs/webhooks/rollbar)
-* [nsq_consumer](https://github.com/influxdata/telegraf/tree/master/plugins/inputs/nsq_consumer)
 
 We'll be adding support for many more over the coming months. Read on if you
 want to add support for another service or third-party API.
@@ -243,6 +247,7 @@ want to add support for another service or third-party API.
 * [kafka](https://github.com/influxdata/telegraf/tree/master/plugins/outputs/kafka)
 * [librato](https://github.com/influxdata/telegraf/tree/master/plugins/outputs/librato)
 * [mqtt](https://github.com/influxdata/telegraf/tree/master/plugins/outputs/mqtt)
+* [nats](https://github.com/influxdata/telegraf/tree/master/plugins/outputs/nats)
 * [nsq](https://github.com/influxdata/telegraf/tree/master/plugins/outputs/nsq)
 * [opentsdb](https://github.com/influxdata/telegraf/tree/master/plugins/outputs/opentsdb)
 * [prometheus](https://github.com/influxdata/telegraf/tree/master/plugins/outputs/prometheus_client)

accumulator.go

@@ -2,16 +2,29 @@ package telegraf
 
 import "time"
 
+// Accumulator is an interface for "accumulating" metrics from input plugin(s).
+// The metrics are sent down a channel shared between all input plugins and then
+// flushed on the configured flush_interval.
 type Accumulator interface {
+	// AddFields adds a metric to the accumulator with the given measurement
+	// name, fields, and tags (and timestamp). If a timestamp is not provided,
+	// then the accumulator sets it to "now".
 	// Create a point with a value, decorating it with tags
 	// NOTE: tags is expected to be owned by the caller, don't mutate
 	// it after passing to Add.
-	Add(measurement string,
-		value interface{},
+	AddFields(measurement string,
+		fields map[string]interface{},
 		tags map[string]string,
 		t ...time.Time)
 
-	AddFields(measurement string,
+	// AddGauge is the same as AddFields, but will add the metric as a "Gauge" type
+	AddGauge(measurement string,
+		fields map[string]interface{},
+		tags map[string]string,
+		t ...time.Time)
+
+	// AddCounter is the same as AddFields, but will add the metric as a "Counter" type
+	AddCounter(measurement string,
 		fields map[string]interface{},
 		tags map[string]string,
 		t ...time.Time)

agent/accumulator.go

@@ -38,38 +38,53 @@ type accumulator struct {
 	errCount uint64
 }
 
-func (ac *accumulator) Add(
-	measurement string,
-	value interface{},
-	tags map[string]string,
-	t ...time.Time,
-) {
-	fields := make(map[string]interface{})
-	fields["value"] = value
-
-	if !ac.inputConfig.Filter.ShouldNamePass(measurement) {
-		return
-	}
-
-	ac.AddFields(measurement, fields, tags, t...)
-}
-
 func (ac *accumulator) AddFields(
 	measurement string,
 	fields map[string]interface{},
 	tags map[string]string,
 	t ...time.Time,
 ) {
+	if m := ac.makeMetric(measurement, fields, tags, telegraf.Untyped, t...); m != nil {
+		ac.metrics <- m
+	}
+}
+
+func (ac *accumulator) AddGauge(
+	measurement string,
+	fields map[string]interface{},
+	tags map[string]string,
+	t ...time.Time,
+) {
+	if m := ac.makeMetric(measurement, fields, tags, telegraf.Gauge, t...); m != nil {
+		ac.metrics <- m
+	}
+}
+
+func (ac *accumulator) AddCounter(
+	measurement string,
+	fields map[string]interface{},
+	tags map[string]string,
+	t ...time.Time,
+) {
+	if m := ac.makeMetric(measurement, fields, tags, telegraf.Counter, t...); m != nil {
+		ac.metrics <- m
+	}
+}
+
+// makeMetric either returns a metric, or returns nil if the metric doesn't
+// need to be created (because of filtering, an error, etc.)
+func (ac *accumulator) makeMetric(
+	measurement string,
+	fields map[string]interface{},
+	tags map[string]string,
+	mType telegraf.ValueType,
+	t ...time.Time,
+) telegraf.Metric {
 	if len(fields) == 0 || len(measurement) == 0 {
-		return
+		return nil
 	}
-
-	if !ac.inputConfig.Filter.ShouldNamePass(measurement) {
-		return
-	}
-
-	if !ac.inputConfig.Filter.ShouldTagsPass(tags) {
-		return
+	if tags == nil {
+		tags = make(map[string]string)
 	}
 
 	// Override measurement name if set
@@ -84,9 +99,6 @@ func (ac *accumulator) AddFields(
 		measurement = measurement + ac.inputConfig.MeasurementSuffix
 	}
 
-	if tags == nil {
-		tags = make(map[string]string)
-	}
 	// Apply plugin-wide tags if set
 	for k, v := range ac.inputConfig.Tags {
 		if _, ok := tags[k]; !ok {
@@ -99,44 +111,37 @@ func (ac *accumulator) AddFields(
 			tags[k] = v
 		}
 	}
-	ac.inputConfig.Filter.FilterTags(tags)
 
-	result := make(map[string]interface{})
+	// Apply the metric filter(s)
+	if ok := ac.inputConfig.Filter.Apply(measurement, fields, tags); !ok {
+		return nil
+	}
+
 	for k, v := range fields {
-		// Filter out any filtered fields
-		if ac.inputConfig != nil {
-			if !ac.inputConfig.Filter.ShouldFieldsPass(k) {
-				continue
-			}
-		}
-
 		// Validate uint64 and float64 fields
 		switch val := v.(type) {
 		case uint64:
 			// InfluxDB does not support writing uint64
 			if val < uint64(9223372036854775808) {
-				result[k] = int64(val)
+				fields[k] = int64(val)
 			} else {
-				result[k] = int64(9223372036854775807)
+				fields[k] = int64(9223372036854775807)
 			}
 			continue
 		case float64:
 			// NaNs are invalid values in influxdb, skip measurement
 			if math.IsNaN(val) || math.IsInf(val, 0) {
 				if ac.debug {
-					log.Printf("Measurement [%s] field [%s] has a NaN or Inf "+
+					log.Printf("I! Measurement [%s] field [%s] has a NaN or Inf "+
 						"field, skipping",
 						measurement, k)
 				}
+				delete(fields, k)
 				continue
 			}
 		}
 
-		result[k] = v
-	}
-	fields = nil
-	if len(result) == 0 {
-		return
+		fields[k] = v
 	}
 
 	var timestamp time.Time
@@ -147,15 +152,26 @@ func (ac *accumulator) AddFields(
 	}
 	timestamp = timestamp.Round(ac.precision)
 
-	m, err := telegraf.NewMetric(measurement, tags, result, timestamp)
-	if err != nil {
-		log.Printf("Error adding point [%s]: %s\n", measurement, err.Error())
-		return
+	var m telegraf.Metric
+	var err error
+	switch mType {
+	case telegraf.Counter:
+		m, err = telegraf.NewCounterMetric(measurement, tags, fields, timestamp)
+	case telegraf.Gauge:
+		m, err = telegraf.NewGaugeMetric(measurement, tags, fields, timestamp)
+	default:
+		m, err = telegraf.NewMetric(measurement, tags, fields, timestamp)
 	}
+	if err != nil {
+		log.Printf("E! Error adding point [%s]: %s\n", measurement, err.Error())
+		return nil
+	}
+
 	if ac.trace {
 		fmt.Println("> " + m.String())
 	}
-	ac.metrics <- m
+
+	return m
 }
 
 // AddError passes a runtime error to the accumulator.
@@ -166,7 +182,7 @@ func (ac *accumulator) AddError(err error) {
 	}
 	atomic.AddUint64(&ac.errCount, 1)
 	//TODO suppress/throttle consecutive duplicate errors?
-	log.Printf("ERROR in input [%s]: %s", ac.inputConfig.Name, err)
+	log.Printf("E! Error in input [%s]: %s", ac.inputConfig.Name, err)
 }
 
 func (ac *accumulator) Debug() bool {

agent/accumulator_test.go

@@ -23,9 +23,15 @@ func TestAdd(t *testing.T) {
 	defer close(a.metrics)
 	a.inputConfig = &models.InputConfig{}
 
-	a.Add("acctest", float64(101), map[string]string{})
-	a.Add("acctest", float64(101), map[string]string{"acc": "test"})
-	a.Add("acctest", float64(101), map[string]string{"acc": "test"}, now)
+	a.AddFields("acctest",
+		map[string]interface{}{"value": float64(101)},
+		map[string]string{})
+	a.AddFields("acctest",
+		map[string]interface{}{"value": float64(101)},
+		map[string]string{"acc": "test"})
+	a.AddFields("acctest",
+		map[string]interface{}{"value": float64(101)},
+		map[string]string{"acc": "test"}, now)
 
 	testm := <-a.metrics
 	actual := testm.String()
@@ -42,6 +48,76 @@ func TestAdd(t *testing.T) {
 		actual)
 }
 
+func TestAddGauge(t *testing.T) {
+	a := accumulator{}
+	now := time.Now()
+	a.metrics = make(chan telegraf.Metric, 10)
+	defer close(a.metrics)
+	a.inputConfig = &models.InputConfig{}
+
+	a.AddGauge("acctest",
+		map[string]interface{}{"value": float64(101)},
+		map[string]string{})
+	a.AddGauge("acctest",
+		map[string]interface{}{"value": float64(101)},
+		map[string]string{"acc": "test"})
+	a.AddGauge("acctest",
+		map[string]interface{}{"value": float64(101)},
+		map[string]string{"acc": "test"}, now)
+
+	testm := <-a.metrics
+	actual := testm.String()
+	assert.Contains(t, actual, "acctest value=101")
+	assert.Equal(t, testm.Type(), telegraf.Gauge)
+
+	testm = <-a.metrics
+	actual = testm.String()
+	assert.Contains(t, actual, "acctest,acc=test value=101")
+	assert.Equal(t, testm.Type(), telegraf.Gauge)
+
+	testm = <-a.metrics
+	actual = testm.String()
+	assert.Equal(t,
+		fmt.Sprintf("acctest,acc=test value=101 %d", now.UnixNano()),
+		actual)
+	assert.Equal(t, testm.Type(), telegraf.Gauge)
+}
+
+func TestAddCounter(t *testing.T) {
+	a := accumulator{}
+	now := time.Now()
+	a.metrics = make(chan telegraf.Metric, 10)
+	defer close(a.metrics)
+	a.inputConfig = &models.InputConfig{}
+
+	a.AddCounter("acctest",
+		map[string]interface{}{"value": float64(101)},
+		map[string]string{})
+	a.AddCounter("acctest",
+		map[string]interface{}{"value": float64(101)},
+		map[string]string{"acc": "test"})
+	a.AddCounter("acctest",
+		map[string]interface{}{"value": float64(101)},
+		map[string]string{"acc": "test"}, now)
+
+	testm := <-a.metrics
+	actual := testm.String()
+	assert.Contains(t, actual, "acctest value=101")
+	assert.Equal(t, testm.Type(), telegraf.Counter)
+
+	testm = <-a.metrics
+	actual = testm.String()
+	assert.Contains(t, actual, "acctest,acc=test value=101")
+	assert.Equal(t, testm.Type(), telegraf.Counter)
+
+	testm = <-a.metrics
+	actual = testm.String()
+	assert.Equal(t,
+		fmt.Sprintf("acctest,acc=test value=101 %d", now.UnixNano()),
+		actual)
+	assert.Equal(t, testm.Type(), telegraf.Counter)
+}
+
 func TestAddNoPrecisionWithInterval(t *testing.T) {
 	a := accumulator{}
 	now := time.Date(2006, time.February, 10, 12, 0, 0, 82912748, time.UTC)
@@ -50,9 +126,15 @@ func TestAddNoPrecisionWithInterval(t *testing.T) {
 	a.inputConfig = &models.InputConfig{}
 
 	a.SetPrecision(0, time.Second)
-	a.Add("acctest", float64(101), map[string]string{})
-	a.Add("acctest", float64(101), map[string]string{"acc": "test"})
-	a.Add("acctest", float64(101), map[string]string{"acc": "test"}, now)
+	a.AddFields("acctest",
+		map[string]interface{}{"value": float64(101)},
+		map[string]string{})
+	a.AddFields("acctest",
+		map[string]interface{}{"value": float64(101)},
+		map[string]string{"acc": "test"})
+	a.AddFields("acctest",
+		map[string]interface{}{"value": float64(101)},
+		map[string]string{"acc": "test"}, now)
 
 	testm := <-a.metrics
 	actual := testm.String()
@@ -77,9 +159,15 @@ func TestAddNoIntervalWithPrecision(t *testing.T) {
 	a.inputConfig = &models.InputConfig{}
 
 	a.SetPrecision(time.Second, time.Millisecond)
-	a.Add("acctest", float64(101), map[string]string{})
-	a.Add("acctest", float64(101), map[string]string{"acc": "test"})
-	a.Add("acctest", float64(101), map[string]string{"acc": "test"}, now)
+	a.AddFields("acctest",
+		map[string]interface{}{"value": float64(101)},
+		map[string]string{})
+	a.AddFields("acctest",
+		map[string]interface{}{"value": float64(101)},
+		map[string]string{"acc": "test"})
+	a.AddFields("acctest",
+		map[string]interface{}{"value": float64(101)},
+		map[string]string{"acc": "test"}, now)
 
 	testm := <-a.metrics
 	actual := testm.String()
@@ -105,9 +193,15 @@ func TestAddDisablePrecision(t *testing.T) {
 
 	a.SetPrecision(time.Second, time.Millisecond)
 	a.DisablePrecision()
-	a.Add("acctest", float64(101), map[string]string{})
-	a.Add("acctest", float64(101), map[string]string{"acc": "test"})
-	a.Add("acctest", float64(101), map[string]string{"acc": "test"}, now)
+	a.AddFields("acctest",
+		map[string]interface{}{"value": float64(101)},
+		map[string]string{})
+	a.AddFields("acctest",
+		map[string]interface{}{"value": float64(101)},
+		map[string]string{"acc": "test"})
+	a.AddFields("acctest",
+		map[string]interface{}{"value": float64(101)},
+		map[string]string{"acc": "test"}, now)
 
 	testm := <-a.metrics
 	actual := testm.String()
@@ -132,7 +226,9 @@ func TestDifferentPrecisions(t *testing.T) {
 	a.inputConfig = &models.InputConfig{}
 
 	a.SetPrecision(0, time.Second)
-	a.Add("acctest", float64(101), map[string]string{"acc": "test"}, now)
+	a.AddFields("acctest",
+		map[string]interface{}{"value": float64(101)},
+		map[string]string{"acc": "test"}, now)
 	testm := <-a.metrics
 	actual := testm.String()
 	assert.Equal(t,
@@ -140,7 +236,9 @@ func TestDifferentPrecisions(t *testing.T) {
 		actual)
 
 	a.SetPrecision(0, time.Millisecond)
-	a.Add("acctest", float64(101), map[string]string{"acc": "test"}, now)
+	a.AddFields("acctest",
+		map[string]interface{}{"value": float64(101)},
+		map[string]string{"acc": "test"}, now)
 	testm = <-a.metrics
 	actual = testm.String()
 	assert.Equal(t,
@@ -148,7 +246,9 @@ func TestDifferentPrecisions(t *testing.T) {
 		actual)
 
 	a.SetPrecision(0, time.Microsecond)
-	a.Add("acctest", float64(101), map[string]string{"acc": "test"}, now)
+	a.AddFields("acctest",
+		map[string]interface{}{"value": float64(101)},
+		map[string]string{"acc": "test"}, now)
 	testm = <-a.metrics
 	actual = testm.String()
 	assert.Equal(t,
@@ -156,7 +256,9 @@ func TestDifferentPrecisions(t *testing.T) {
 		actual)
 
 	a.SetPrecision(0, time.Nanosecond)
-	a.Add("acctest", float64(101), map[string]string{"acc": "test"}, now)
+	a.AddFields("acctest",
+		map[string]interface{}{"value": float64(101)},
+		map[string]string{"acc": "test"}, now)
 	testm = <-a.metrics
 	actual = testm.String()
 	assert.Equal(t,
@@ -172,9 +274,15 @@ func TestAddDefaultTags(t *testing.T) {
 	defer close(a.metrics)
 	a.inputConfig = &models.InputConfig{}
 
-	a.Add("acctest", float64(101), map[string]string{})
-	a.Add("acctest", float64(101), map[string]string{"acc": "test"})
-	a.Add("acctest", float64(101), map[string]string{"acc": "test"}, now)
+	a.AddFields("acctest",
+		map[string]interface{}{"value": float64(101)},
+		map[string]string{})
+	a.AddFields("acctest",
+		map[string]interface{}{"value": float64(101)},
+		map[string]string{"acc": "test"})
+	a.AddFields("acctest",
+		map[string]interface{}{"value": float64(101)},
+		map[string]string{"acc": "test"}, now)
 
 	testm := <-a.metrics
 	actual := testm.String()
@@ -342,9 +450,15 @@ func TestAddInts(t *testing.T) {
 	defer close(a.metrics)
 	a.inputConfig = &models.InputConfig{}
 
-	a.Add("acctest", int(101), map[string]string{})
-	a.Add("acctest", int32(101), map[string]string{"acc": "test"})
-	a.Add("acctest", int64(101), map[string]string{"acc": "test"}, now)
+	a.AddFields("acctest",
+		map[string]interface{}{"value": int(101)},
+		map[string]string{})
+	a.AddFields("acctest",
+		map[string]interface{}{"value": int32(101)},
+		map[string]string{"acc": "test"})
+	a.AddFields("acctest",
+		map[string]interface{}{"value": int64(101)},
+		map[string]string{"acc": "test"}, now)
 
 	testm := <-a.metrics
 	actual := testm.String()
@@ -369,8 +483,12 @@ func TestAddFloats(t *testing.T) {
 	defer close(a.metrics)
 	a.inputConfig = &models.InputConfig{}
 
-	a.Add("acctest", float32(101), map[string]string{"acc": "test"})
-	a.Add("acctest", float64(101), map[string]string{"acc": "test"}, now)
+	a.AddFields("acctest",
+		map[string]interface{}{"value": float32(101)},
+		map[string]string{"acc": "test"})
+	a.AddFields("acctest",
+		map[string]interface{}{"value": float64(101)},
+		map[string]string{"acc": "test"}, now)
 
 	testm := <-a.metrics
 	actual := testm.String()
@@ -391,8 +509,12 @@ func TestAddStrings(t *testing.T) {
 	defer close(a.metrics)
 	a.inputConfig = &models.InputConfig{}
 
-	a.Add("acctest", "test", map[string]string{"acc": "test"})
-	a.Add("acctest", "foo", map[string]string{"acc": "test"}, now)
+	a.AddFields("acctest",
+		map[string]interface{}{"value": "test"},
+		map[string]string{"acc": "test"})
+	a.AddFields("acctest",
+		map[string]interface{}{"value": "foo"},
+		map[string]string{"acc": "test"}, now)
 
 	testm := <-a.metrics
 	actual := testm.String()
@@ -413,8 +535,10 @@ func TestAddBools(t *testing.T) {
 	defer close(a.metrics)
 	a.inputConfig = &models.InputConfig{}
 
-	a.Add("acctest", true, map[string]string{"acc": "test"})
-	a.Add("acctest", false, map[string]string{"acc": "test"}, now)
+	a.AddFields("acctest",
+		map[string]interface{}{"value": true}, map[string]string{"acc": "test"})
+	a.AddFields("acctest",
+		map[string]interface{}{"value": false}, map[string]string{"acc": "test"}, now)
 
 	testm := <-a.metrics
 	actual := testm.String()
@@ -436,13 +560,19 @@ func TestAccFilterTags(t *testing.T) {
 	filter := models.Filter{
 		TagExclude: []string{"acc"},
 	}
-	assert.NoError(t, filter.CompileFilter())
+	assert.NoError(t, filter.Compile())
 	a.inputConfig = &models.InputConfig{}
 	a.inputConfig.Filter = filter
 
-	a.Add("acctest", float64(101), map[string]string{})
-	a.Add("acctest", float64(101), map[string]string{"acc": "test"})
-	a.Add("acctest", float64(101), map[string]string{"acc": "test"}, now)
+	a.AddFields("acctest",
+		map[string]interface{}{"value": float64(101)},
+		map[string]string{})
+	a.AddFields("acctest",
+		map[string]interface{}{"value": float64(101)},
+		map[string]string{"acc": "test"})
+	a.AddFields("acctest",
+		map[string]interface{}{"value": float64(101)},
+		map[string]string{"acc": "test"}, now)
 
 	testm := <-a.metrics
 	actual := testm.String()

agent/agent.go

@@ -49,18 +49,16 @@ func (a *Agent) Connect() error {
 		switch ot := o.Output.(type) {
 		case telegraf.ServiceOutput:
 			if err := ot.Start(); err != nil {
-				log.Printf("Service for output %s failed to start, exiting\n%s\n",
+				log.Printf("E! Service for output %s failed to start, exiting\n%s\n",
 					o.Name, err.Error())
 				return err
 			}
 		}
 
-		if a.Config.Agent.Debug {
-			log.Printf("Attempting connection to output: %s\n", o.Name)
-		}
+		log.Printf("D! Attempting connection to output: %s\n", o.Name)
 		err := o.Output.Connect()
 		if err != nil {
-			log.Printf("Failed to connect to output %s, retrying in 15s, "+
+			log.Printf("E! Failed to connect to output %s, retrying in 15s, "+
 				"error was '%s' \n", o.Name, err)
 			time.Sleep(15 * time.Second)
 			err = o.Output.Connect()
@@ -68,9 +66,7 @@ func (a *Agent) Connect() error {
 				return err
 			}
 		}
-		if a.Config.Agent.Debug {
-			log.Printf("Successfully connected to output: %s\n", o.Name)
-		}
+		log.Printf("D! Successfully connected to output: %s\n", o.Name)
 	}
 	return nil
 }
@@ -92,9 +88,9 @@ func panicRecover(input *models.RunningInput) {
 	if err := recover(); err != nil {
 		trace := make([]byte, 2048)
 		runtime.Stack(trace, true)
-		log.Printf("FATAL: Input [%s] panicked: %s, Stack:\n%s\n",
+		log.Printf("E! FATAL: Input [%s] panicked: %s, Stack:\n%s\n",
 			input.Name, err, trace)
-		log.Println("PLEASE REPORT THIS PANIC ON GITHUB with " +
+		log.Println("E! PLEASE REPORT THIS PANIC ON GITHUB with " +
 			"stack trace, configuration, and OS information: " +
 			"https://github.com/influxdata/telegraf/issues/new")
 	}
@@ -117,7 +113,6 @@ func (a *Agent) gatherer(
 		var outerr error
 
 		acc := NewAccumulator(input.Config, metricC)
-		acc.SetDebug(a.Config.Agent.Debug)
 		acc.SetPrecision(a.Config.Agent.Precision.Duration,
 			a.Config.Agent.Interval.Duration)
 		acc.setDefaultTags(a.Config.Tags)
@@ -131,10 +126,8 @@ func (a *Agent) gatherer(
 		if outerr != nil {
 			return outerr
 		}
-		if a.Config.Agent.Debug {
-			log.Printf("Input [%s] gathered metrics, (%s interval) in %s\n",
-				input.Name, interval, elapsed)
-		}
+		log.Printf("D! Input [%s] gathered metrics, (%s interval) in %s\n",
+			input.Name, interval, elapsed)
 
 		select {
 		case <-shutdown:
@@ -167,11 +160,11 @@ func gatherWithTimeout(
 		select {
 		case err := <-done:
 			if err != nil {
-				log.Printf("ERROR in input [%s]: %s", input.Name, err)
+				log.Printf("E! ERROR in input [%s]: %s", input.Name, err)
 			}
 			return
 		case <-ticker.C:
-			log.Printf("ERROR: input [%s] took longer to collect than "+
+			log.Printf("E! ERROR: input [%s] took longer to collect than "+
 				"collection interval (%s)",
 				input.Name, timeout)
 			continue
@@ -244,7 +237,7 @@ func (a *Agent) flush() {
 			defer wg.Done()
 			err := output.Write()
 			if err != nil {
-				log.Printf("Error writing to output [%s]: %s\n",
+				log.Printf("E! Error writing to output [%s]: %s\n",
 					output.Name, err.Error())
 			}
 		}(o)
@@ -264,7 +257,7 @@ func (a *Agent) flusher(shutdown chan struct{}, metricC chan telegraf.Metric) er
 	for {
 		select {
 		case <-shutdown:
-			log.Println("Hang on, flushing any cached metrics before shutdown")
+			log.Println("I! Hang on, flushing any cached metrics before shutdown")
 			a.flush()
 			return nil
 		case <-ticker.C:
@@ -302,9 +295,9 @@ func copyMetric(m telegraf.Metric) telegraf.Metric {
 func (a *Agent) Run(shutdown chan struct{}) error {
 	var wg sync.WaitGroup
 
-	log.Printf("Agent Config: Interval:%s, Debug:%#v, Quiet:%#v, Hostname:%#v, "+
+	log.Printf("I! Agent Config: Interval:%s, Quiet:%#v, Hostname:%#v, "+
 		"Flush Interval:%s \n",
-		a.Config.Agent.Interval.Duration, a.Config.Agent.Debug, a.Config.Agent.Quiet,
+		a.Config.Agent.Interval.Duration, a.Config.Agent.Quiet,
 		a.Config.Agent.Hostname, a.Config.Agent.FlushInterval.Duration)
 
 	// channel shared between all input threads for accumulating metrics
@@ -315,13 +308,12 @@ func (a *Agent) Run(shutdown chan struct{}) error {
 		switch p := input.Input.(type) {
 		case telegraf.ServiceInput:
 			acc := NewAccumulator(input.Config, metricC)
-			acc.SetDebug(a.Config.Agent.Debug)
 			// Service input plugins should set their own precision of their
 			// metrics.
 			acc.DisablePrecision()
 			acc.setDefaultTags(a.Config.Tags)
 			if err := p.Start(acc); err != nil {
-				log.Printf("Service for input %s failed to start, exiting\n%s\n",
+				log.Printf("E! Service for input %s failed to start, exiting\n%s\n",
 					input.Name, err.Error())
 				return err
 			}
@@ -339,7 +331,7 @@ func (a *Agent) Run(shutdown chan struct{}) error {
 	go func() {
 		defer wg.Done()
 		if err := a.flusher(shutdown, metricC); err != nil {
-			log.Printf("Flusher routine failed, exiting: %s\n", err.Error())
+			log.Printf("E! Flusher routine failed, exiting: %s\n", err.Error())
 			close(shutdown)
 		}
 	}()
@@ -354,7 +346,7 @@ func (a *Agent) Run(shutdown chan struct{}) error {
 		go func(in *models.RunningInput, interv time.Duration) {
 			defer wg.Done()
 			if err := a.gatherer(shutdown, in, interv, metricC); err != nil {
-				log.Printf(err.Error())
+				log.Printf("E! " + err.Error())
 			}
 		}(input, interval)
 	}

circle.yml

@@ -4,9 +4,9 @@ machine:
   post:
     - sudo service zookeeper stop
     - go version
-    - go version | grep 1.6.2 || sudo rm -rf /usr/local/go
-    - wget https://storage.googleapis.com/golang/go1.6.2.linux-amd64.tar.gz
-    - sudo tar -C /usr/local -xzf go1.6.2.linux-amd64.tar.gz
+    - go version | grep 1.7.1 || sudo rm -rf /usr/local/go
+    - wget https://storage.googleapis.com/golang/go1.7.1.linux-amd64.tar.gz
+    - sudo tar -C /usr/local -xzf go1.7.1.linux-amd64.tar.gz
     - go version
 
 dependencies:

cmd/telegraf/telegraf.go

@@ -12,15 +12,17 @@ import (
 
 	"github.com/influxdata/telegraf/agent"
 	"github.com/influxdata/telegraf/internal/config"
+	"github.com/influxdata/telegraf/logger"
 	"github.com/influxdata/telegraf/plugins/inputs"
 	_ "github.com/influxdata/telegraf/plugins/inputs/all"
 	"github.com/influxdata/telegraf/plugins/outputs"
 	_ "github.com/influxdata/telegraf/plugins/outputs/all"
+
 	"github.com/kardianos/service"
 )
 
 var fDebug = flag.Bool("debug", false,
-	"show metrics as they're generated to stdout")
+	"turn on debug logging")
 var fQuiet = flag.Bool("quiet", false,
 	"run in quiet mode")
 var fTest = flag.Bool("test", false, "gather metrics, print them out, and exit")
@@ -52,6 +54,16 @@ var (
 	branch  string
 )
 
+func init() {
+	// If commit or branch are not set, make that clear.
+	if commit == "" {
+		commit = "unknown"
+	}
+	if branch == "" {
+		branch = "unknown"
+	}
+}
+
 const usage = `Telegraf, The plugin-driven server agent for collecting and reporting metrics.
 
 Usage:
@@ -99,12 +111,9 @@ Examples:
   telegraf -config telegraf.conf -input-filter cpu:mem -output-filter influxdb
 `
 
-var logger service.Logger
-
 var stop chan struct{}
 
 var srvc service.Service
-var svcConfig *service.Config
 
 type program struct{}
 
@@ -137,8 +146,7 @@ func reloadLoop(stop chan struct{}, s service.Service) {
 		if len(args) > 0 {
 			switch args[0] {
 			case "version":
-				v := fmt.Sprintf("Telegraf - version %s", version)
-				fmt.Println(v)
+				fmt.Printf("Telegraf v%s (git: %s %s)\n", version, branch, commit)
 				return
 			case "config":
 				config.PrintSampleConfig(inputFilters, outputFilters)
@@ -161,8 +169,7 @@ func reloadLoop(stop chan struct{}, s service.Service) {
 			}
 			return
 		case *fVersion:
-			v := fmt.Sprintf("Telegraf - version %s", version)
-			fmt.Println(v)
+			fmt.Printf("Telegraf v%s (git: %s %s)\n", version, branch, commit)
 			return
 		case *fSampleConfig:
 			config.PrintSampleConfig(inputFilters, outputFilters)
@@ -174,15 +181,6 @@ func reloadLoop(stop chan struct{}, s service.Service) {
 				}
 			}
 			return
-		case *fService != "" && runtime.GOOS == "windows":
-			if *fConfig != "" {
-				(*svcConfig).Arguments = []string{"-config", *fConfig}
-			}
-			err := service.Control(s, *fService)
-			if err != nil {
-				log.Fatal(err)
-			}
-			return
 		}
 
 		// If no other options are specified, load the config file and run.
@@ -213,13 +211,12 @@ func reloadLoop(stop chan struct{}, s service.Service) {
 			log.Fatal(err)
 		}
 
-		if *fDebug {
-			ag.Config.Agent.Debug = true
-		}
-
-		if *fQuiet {
-			ag.Config.Agent.Quiet = true
-		}
+		// Setup logging
+		logger.SetupLogging(
+			ag.Config.Agent.Debug || *fDebug,
+			ag.Config.Agent.Quiet || *fQuiet,
+			ag.Config.Agent.Logfile,
+		)
 
 		if *fTest {
 			err = ag.Test()
@@ -244,7 +241,7 @@ func reloadLoop(stop chan struct{}, s service.Service) {
 					close(shutdown)
 				}
 				if sig == syscall.SIGHUP {
-					log.Printf("Reloading Telegraf config\n")
+					log.Printf("I! Reloading Telegraf config\n")
 					<-reload
 					reload <- true
 					close(shutdown)
@@ -254,10 +251,10 @@ func reloadLoop(stop chan struct{}, s service.Service) {
 			}
 		}()
 
-		log.Printf("Starting Telegraf (version %s)\n", version)
-		log.Printf("Loaded outputs: %s", strings.Join(c.OutputNames(), " "))
-		log.Printf("Loaded inputs: %s", strings.Join(c.InputNames(), " "))
-		log.Printf("Tags enabled: %s", c.ListTags())
+		log.Printf("I! Starting Telegraf (version %s)\n", version)
+		log.Printf("I! Loaded outputs: %s", strings.Join(c.OutputNames(), " "))
+		log.Printf("I! Loaded inputs: %s", strings.Join(c.InputNames(), " "))
+		log.Printf("I! Tags enabled: %s", c.ListTags())
 
 		if *fPidfile != "" {
 			f, err := os.Create(*fPidfile)
@@ -294,8 +291,9 @@ func (p *program) Stop(s service.Service) error {
 }
 
 func main() {
+	flag.Parse()
 	if runtime.GOOS == "windows" {
-		svcConfig = &service.Config{
+		svcConfig := &service.Config{
 			Name:        "telegraf",
 			DisplayName: "Telegraf Data Collector Service",
 			Description: "Collects data using a series of plugins and publishes it to" +
@@ -308,13 +306,21 @@ func main() {
 		if err != nil {
 			log.Fatal(err)
 		}
-		logger, err = s.Logger(nil)
-		if err != nil {
-			log.Fatal(err)
-		}
-		err = s.Run()
-		if err != nil {
-			logger.Error(err)
+		// Handle the -service flag here to prevent any issues with tooling that
+		// may not have an interactive session, e.g. installing from Ansible.
+		if *fService != "" {
+			if *fConfig != "" {
+				(*svcConfig).Arguments = []string{"-config", *fConfig}
+			}
+			err := service.Control(s, *fService)
+			if err != nil {
+				log.Fatal(err)
+			}
+		} else {
+			err = s.Run()
+			if err != nil {
+				log.Println("E! " + err.Error())
+			}
 		}
 	} else {
 		stop = make(chan struct{})

docs/CONFIGURATION.md

@@ -86,6 +86,10 @@ as it is more efficient to filter out tags at the ingestion point.
 * **taginclude**: taginclude is the inverse of tagexclude. It will only include
 the tag keys in the final measurement.
 
+**NOTE** `tagpass` and `tagdrop` parameters must be defined at the _end_ of
+the plugin definition, otherwise subsequent plugin config options will be
+interpreted as part of the tagpass/tagdrop map.
+
 ## Input Configuration
 
 Some configuration options are configurable per input:
@@ -129,6 +133,10 @@ fields which begin with `time_`.
 
 #### Input Config: tagpass and tagdrop
 
+**NOTE** `tagpass` and `tagdrop` parameters must be defined at the _end_ of
+the plugin definition, otherwise subsequent plugin config options will be
+interpreted as part of the tagpass/tagdrop map.
+
 ```toml
 [[inputs.cpu]]
   percpu = true

docs/WINDOWS_SERVICE.md

@@ -6,19 +6,18 @@ the general steps to set it up.
 1. Obtain the telegraf windows distribution
 2. Create the directory `C:\Program Files\Telegraf` (if you install in a different
    location simply specify the `-config` parameter with the desired location)
-3. Place the telegraf.exe and the config file into `C:\Program Files\Telegraf`
-4. To install the service into the Windows Service Manager, run (as an
-   administrator):
+3. Place the telegraf.exe and the telegraf.conf config file into `C:\Program Files\Telegraf`
+4. To install the service into the Windows Service Manager, run the following in PowerShell as an administrator (If necessary, you can wrap any spaces in the file paths in double quotes ""):
 
    ```
-   > C:\Program Files\Telegraf\telegraf.exe --service install
+   > C:\"Program Files"\Telegraf\telegraf.exe --service install
    ```
 
 5. Edit the configuration file to meet your needs
 6. To check that it works, run:
 
    ```
-   > C:\Program Files\Telegraf\telegraf.exe --config C:\Program Files\Telegraf\telegraf.conf --test
+   > C:\"Program Files"\Telegraf\telegraf.exe --config C:\"Program Files"\Telegraf\telegraf.conf --test
    ```
 
 7. To start collecting data, run:

etc/telegraf.conf

@@ -30,12 +30,15 @@
   ## ie, if interval="10s" then always collect on :00, :10, :20, etc.
   round_interval = true
 
-  ## Telegraf will send metrics to outputs in batches of at
-  ## most metric_batch_size metrics.
+  ## Telegraf will send metrics to outputs in batches of at most
+  ## metric_batch_size metrics.
+  ## This controls the size of writes that Telegraf sends to output plugins.
   metric_batch_size = 1000
+
   ## For failed writes, telegraf will cache metric_buffer_limit metrics for each
   ## output, and will flush this buffer on a successful write. Oldest metrics
   ## are dropped first when this buffer fills.
+  ## This buffer only fills when writes fail to output plugin(s).
   metric_buffer_limit = 10000
 
   ## Collection jitter is used to jitter the collection by a random amount.
@@ -57,10 +60,15 @@
   ## Precision will NOT be used for service inputs, such as logparser and statsd.
   ## Valid values are "ns", "us" (or "µs"), "ms", "s".
   precision = ""
-  ## Run telegraf in debug mode
+
+  ## Logging configuration:
+  ## Run telegraf with debug log messages.
   debug = false
-  ## Run telegraf in quiet mode
+  ## Run telegraf in quiet mode (error log messages only).
   quiet = false
+  ## Specify the log file name. The empty string means to log to stdout.
+  logfile = ""
+
   ## Override default hostname, if empty use os.Hostname()
   hostname = ""
   ## If set to true, do no set the "host" tag in the telegraf agent.
@@ -357,6 +365,30 @@
 #   data_format = "influx"
 
 
+# # Send telegraf measurements to NATS
+# [[outputs.nats]]
+#   ## URLs of NATS servers
+#   servers = ["nats://localhost:4222"]
+#   ## Optional credentials
+#   # username = ""
+#   # password = ""
+#   ## NATS subject for producer messages
+#   subject = "telegraf"
+#
+#   ## Optional SSL Config
+#   # ssl_ca = "/etc/telegraf/ca.pem"
+#   # ssl_cert = "/etc/telegraf/cert.pem"
+#   # ssl_key = "/etc/telegraf/key.pem"
+#   ## Use SSL but skip chain & host verification
+#   # insecure_skip_verify = false
+#
+#   ## Data format to output.
+#   ## Each data format has it's own unique set of configuration options, read
+#   ## more about them here:
+#   ## https://github.com/influxdata/telegraf/blob/master/docs/DATA_FORMATS_OUTPUT.md
+#   data_format = "influx"
+
+
 # # Send telegraf measurements to NSQD
 # [[outputs.nsq]]
 #   ## Location of nsqd instance listening on TCP
@@ -376,13 +408,18 @@
 #   ## prefix for metrics keys
 #   prefix = "my.specific.prefix."
 #
-#   ## Telnet Mode ##
-#   ## DNS name of the OpenTSDB server in telnet mode
+#   ## DNS name of the OpenTSDB server
+#   ## Using "opentsdb.example.com" or "tcp://opentsdb.example.com" will use the
+#   ## telnet API. "http://opentsdb.example.com" will use the Http API.
 #   host = "opentsdb.example.com"
 #
-#   ## Port of the OpenTSDB server in telnet mode
+#   ## Port of the OpenTSDB server
 #   port = 4242
 #
+#   ## Number of data points to send to OpenTSDB in Http requests.
+#   ## Not used with telnet API.
+#   httpBatchSize = 50
+#
 #   ## Debug true - Prints OpenTSDB communication
 #   debug = false
 
@@ -414,8 +451,8 @@
   percpu = true
   ## Whether to report total system cpu stats or not
   totalcpu = true
-  ## Comment this line if you want the raw CPU time metrics
-  fielddrop = ["time_*"]
+  ## If true, collect raw CPU time metrics.
+  collect_cpu_time = false
 
 
 # Read metrics about disk usage by mount point
@@ -511,6 +548,10 @@
 
 # # Collects performance metrics from the MON and OSD nodes in a Ceph storage cluster.
 # [[inputs.ceph]]
+#   ## This is the recommended interval to poll.  Too frequent and you will lose
+#   ## data points due to timeouts during rebalancing and recovery
+#   interval = '1m'
+#
 #   ## All configuration values are optional, defaults are shown below
 #
 #   ## location of ceph binary
@@ -525,6 +566,18 @@
 #
 #   ## suffix used to identify socket files
 #   socket_suffix = "asok"
+#
+#   ## Ceph user to authenticate as
+#   ceph_user = "client.admin"
+#
+#   ## Ceph configuration to use to locate the cluster
+#   ceph_config = "/etc/ceph/ceph.conf"
+#
+#   ## Whether to gather statistics via the admin socket
+#   gather_admin_socket_stats = true
+#
+#   ## Whether to gather statistics via ceph commands
+#   gather_cluster_stats = true
 
 
 # # Read specific statistics per cgroup
@@ -577,6 +630,11 @@
 #   ## Metric Statistic Namespace (required)
 #   namespace = 'AWS/ELB'
 #
+#   ## Maximum requests per second. Note that the global default AWS rate limit is
+#   ## 10 reqs/sec, so if you define multiple namespaces, these should add up to a
+#   ## maximum of 10. Optional - default value is 10.
+#   ratelimit = 10
+#
 #   ## Metrics to Pull (optional)
 #   ## Defaults to all Metrics in Namespace if nothing is provided
 #   ## Refreshes Namespace available metrics every 1h
@@ -694,6 +752,9 @@
 #   ## specify a list of one or more Elasticsearch servers
 #   servers = ["http://localhost:9200"]
 #
+#   ## Timeout for HTTP requests to the elastic search server(s)
+#   http_timeout = "5s"
+#
 #   ## set local to false when you want to read the indices stats from all nodes
 #   ## within the cluster
 #   local = true
@@ -836,6 +897,8 @@
 #     "http://localhost:9999/stats/",
 #     "http://localhost:9998/stats/",
 #   ]
+#   ## Set response_timeout (default 5 seconds)
+#   response_timeout = "5s"
 #
 #   ## HTTP method to use: GET or POST (case-sensitive)
 #   method = "GET"
@@ -875,6 +938,9 @@
 #   urls = [
 #     "http://localhost:8086/debug/vars"
 #   ]
+#
+#   ## http request & header timeout
+#   timeout = "5s"
 
 
 # # Read metrics from one or many bare metal servers
@@ -890,6 +956,7 @@
 # # Read JMX metrics through Jolokia
 # [[inputs.jolokia]]
 #   ## This is the context root used to compose the jolokia url
+#   ## NOTE that your jolokia security policy must allow for POST requests.
 #   context = "/jolokia"
 #
 #   ## This specifies the mode used
@@ -1005,8 +1072,6 @@
 #   #   "tasks",
 #   #   "messages",
 #   # ]
-#   ## Include mesos tasks statistics, default is false
-#   # slave_tasks = true
 
 
 # # Read metrics from one or many MongoDB servers
@@ -1150,23 +1215,6 @@
 #   command = "passenger-status -v --show=xml"
 
 
-# # Read metrics from one or many pgbouncer servers
-# [[inputs.pgbouncer]]
-#   ## specify address via a url matching:
-#   ##   postgres://[pqgotest[:password]]@localhost:port[/dbname]\
-#   ##       ?sslmode=[disable|verify-ca|verify-full]
-#   ## or a simple string:
-#   ##   host=localhost user=pqotest port=6432 password=... sslmode=... dbname=pgbouncer
-#   ##
-#   ## All connection parameters are optional, except for dbname,
-#   ## you need to set it always as pgbouncer.
-#   address = "host=localhost user=postgres port=6432 sslmode=disable dbname=pgbouncer"
-#
-#   ## A list of databases to pull metrics about. If not specified, metrics for all
-#   ## databases are gathered.
-#   # databases = ["app_production", "testing"]
-
-
 # # Read metrics of phpfpm, via HTTP status page or socket
 # [[inputs.phpfpm]]
 #   ## An array of addresses to gather stats about. Specify an ip or hostname
@@ -1225,8 +1273,12 @@
 #   ##
 #   address = "host=localhost user=postgres sslmode=disable"
 #
+#   ## A  list of databases to explicitly ignore.  If not specified, metrics for all
+#   ## databases are gathered.  Do NOT use with the 'databases' option.
+#   # ignored_databases = ["postgres", "template0", "template1"]
+#
 #   ## A list of databases to pull metrics about. If not specified, metrics for all
-#   ## databases are gathered.
+#   ## databases are gathered.  Do NOT use with the 'ignore_databases' option.
 #   # databases = ["app_production", "testing"]
 
 
@@ -1304,6 +1356,8 @@
 #   # exe = "nginx"
 #   ## pattern as argument for pgrep (ie, pgrep -f <pattern>)
 #   # pattern = "nginx"
+#   ## match the exact name of the process (ie, pgrep -xf <pattern>)
+#   # exact = false
 #   ## user as argument for pgrep (ie, pgrep -u <user>)
 #   # user = "nginx"
 #
@@ -1393,6 +1447,65 @@
 #   servers = ["http://localhost:8098"]
 
 
+# # Retrieves SNMP values from remote agents
+# [[inputs.snmp]]
+#   agents = [ "127.0.0.1:161" ]
+#   ## Timeout for each SNMP query.
+#   timeout = "5s"
+#   ## Number of retries to attempt within timeout.
+#   retries = 3
+#   ## SNMP version, values can be 1, 2, or 3
+#   version = 2
+#
+#   ## SNMP community string.
+#   community = "public"
+#
+#   ## The GETBULK max-repetitions parameter
+#   max_repetitions = 10
+#
+#   ## SNMPv3 auth parameters
+#   #sec_name = "myuser"
+#   #auth_protocol = "md5"      # Values: "MD5", "SHA", ""
+#   #auth_password = "pass"
+#   #sec_level = "authNoPriv"   # Values: "noAuthNoPriv", "authNoPriv", "authPriv"
+#   #context_name = ""
+#   #priv_protocol = ""         # Values: "DES", "AES", ""
+#   #priv_password = ""
+#
+#   ## measurement name
+#   name = "system"
+#   [[inputs.snmp.field]]
+#     name = "hostname"
+#     oid = ".1.0.0.1.1"
+#   [[inputs.snmp.field]]
+#     name = "uptime"
+#     oid = ".1.0.0.1.2"
+#   [[inputs.snmp.field]]
+#     name = "load"
+#     oid = ".1.0.0.1.3"
+#   [[inputs.snmp.field]]
+#     oid = "HOST-RESOURCES-MIB::hrMemorySize"
+#
+#   [[inputs.snmp.table]]
+#     ## measurement name
+#     name = "remote_servers"
+#     inherit_tags = [ "hostname" ]
+#     [[inputs.snmp.table.field]]
+#       name = "server"
+#       oid = ".1.0.0.0.1.0"
+#       is_tag = true
+#     [[inputs.snmp.table.field]]
+#       name = "connections"
+#       oid = ".1.0.0.0.1.1"
+#     [[inputs.snmp.table.field]]
+#       name = "latency"
+#       oid = ".1.0.0.0.1.2"
+#
+#   [[inputs.snmp.table]]
+#     ## auto populate table's fields using the MIB
+#     oid = "HOST-RESOURCES-MIB::hrNetworkTable"
+
+
 # # DEPRECATED! PLEASE USE inputs.snmp INSTEAD.
 # [[inputs.snmp_legacy]]
 #   ## Use 'oids.txt' file to translate oids to names
@@ -1565,6 +1678,16 @@
 #                            SERVICE INPUT PLUGINS                            #
 ###############################################################################
 
+# # Influx HTTP write listener
+# [[inputs.http_listener]]
+#   ## Address and port to host HTTP listener on
+#   service_address = ":8186"
+#
+#   ## timeouts
+#   read_timeout = "10s"
+#   write_timeout = "10s"
+
+
 # # Read metrics from Kafka topic(s)
 # [[inputs.kafka_consumer]]
 #   ## topic(s) to consume
@@ -1787,6 +1910,9 @@
 #   ## Address and port to host Webhook listener on
 #   service_address = ":1619"
 #
+#   [inputs.webhooks.filestack]
+#     path = "/filestack"
+#
 #   [inputs.webhooks.github]
 #     path = "/github"
 #

etc/telegraf_windows.conf

@@ -42,10 +42,14 @@
   ## ie, a jitter of 5s and interval 10s means flushes will happen every 10-15s
   flush_jitter = "0s"
 
+  ## Logging configuration:
   ## Run telegraf in debug mode
   debug = false
   ## Run telegraf in quiet mode
   quiet = false
+  ## Specify the log file name. The empty string means to log to stdout.
+  logfile = "/Program Files/Telegraf/telegraf.log"
+
   ## Override default hostname, if empty use os.Hostname()
   hostname = ""
 
@@ -85,7 +89,7 @@
 # Windows Performance Counters plugin.
 # These are the recommended method of monitoring system metrics on windows,
 # as the regular system plugins (inputs.cpu, inputs.mem, etc.) rely on WMI,
-# which utilizes a lot of system resources.
+# which utilize more system resources.
 #
 # See more configuration examples at:
 #   https://github.com/influxdata/telegraf/tree/master/plugins/inputs/win_perf_counters
@@ -95,70 +99,104 @@
     # Processor usage, alternative to native, reports on a per core.
     ObjectName = "Processor"
     Instances = ["*"]
-    Counters = ["% Idle Time", "% Interrupt Time", "% Privileged Time", "% User Time", "% Processor Time"]
+    Counters = [
+      "% Idle Time",
+      "% Interrupt Time",
+      "% Privileged Time",
+      "% User Time",
+      "% Processor Time",
+    ]
     Measurement = "win_cpu"
-    #IncludeTotal=false #Set to true to include _Total instance when querying for all (*).
+    # Set to true to include _Total instance when querying for all (*).
+    #IncludeTotal=false
 
   [[inputs.win_perf_counters.object]]
     # Disk times and queues
     ObjectName = "LogicalDisk"
     Instances = ["*"]
-    Counters = ["% Idle Time", "% Disk Time","% Disk Read Time", "% Disk Write Time", "% User Time", "Current Disk Queue Length"]
+    Counters = [
+      "% Idle Time",
+      "% Disk Time","% Disk Read Time",
+      "% Disk Write Time",
+      "% User Time",
+      "Current Disk Queue Length",
+    ]
     Measurement = "win_disk"
-    #IncludeTotal=false #Set to true to include _Total instance when querying for all (*).
+    # Set to true to include _Total instance when querying for all (*).
+    #IncludeTotal=false
 
   [[inputs.win_perf_counters.object]]
     ObjectName = "System"
-    Counters = ["Context Switches/sec","System Calls/sec"]
+    Counters = [
+      "Context Switches/sec",
+      "System Calls/sec",
+    ]
     Instances = ["------"]
     Measurement = "win_system"
-    #IncludeTotal=false #Set to true to include _Total instance when querying for all (*).
+    # Set to true to include _Total instance when querying for all (*).
+    #IncludeTotal=false
 
   [[inputs.win_perf_counters.object]]
-    # Example query where the Instance portion must be removed to get data back, such as from the Memory object.
+    # Example query where the Instance portion must be removed to get data back,
+    # such as from the Memory object.
     ObjectName = "Memory"
-    Counters = ["Available Bytes","Cache Faults/sec","Demand Zero Faults/sec","Page Faults/sec","Pages/sec","Transition Faults/sec","Pool Nonpaged Bytes","Pool Paged Bytes"]
-    Instances = ["------"] # Use 6 x - to remove the Instance bit from the query.
+    Counters = [
+      "Available Bytes",
+      "Cache Faults/sec",
+      "Demand Zero Faults/sec",
+      "Page Faults/sec",
+      "Pages/sec",
+      "Transition Faults/sec",
+      "Pool Nonpaged Bytes",
+      "Pool Paged Bytes",
+    ]
+    # Use 6 x - to remove the Instance bit from the query.
+    Instances = ["------"]
     Measurement = "win_mem"
-    #IncludeTotal=false #Set to true to include _Total instance when querying for all (*).
+    # Set to true to include _Total instance when querying for all (*).
+    #IncludeTotal=false
 
 
 # Windows system plugins using WMI (disabled by default, using
 # win_perf_counters over WMI is recommended)
 
-# Read metrics about cpu usage
-#[[inputs.cpu]]
-  ## Whether to report per-cpu stats or not
-  #percpu = true
-  ## Whether to report total system cpu stats or not
-  #totalcpu = true
-  ## Comment this line if you want the raw CPU time metrics
-  #fielddrop = ["time_*"]
+# # Read metrics about cpu usage
+# [[inputs.cpu]]
+#   ## Whether to report per-cpu stats or not
+#   percpu = true
+#   ## Whether to report total system cpu stats or not
+#   totalcpu = true
+#   ## Comment this line if you want the raw CPU time metrics
+#   fielddrop = ["time_*"]
 
-# Read metrics about disk usage by mount point
-#[[inputs.disk]]
-  ## By default, telegraf gather stats for all mountpoints.
-  ## Setting mountpoints will restrict the stats to the specified mountpoints.
-  ## mount_points=["/"]
 
-  ## Ignore some mountpoints by filesystem type. For example (dev)tmpfs (usually
-  ## present on /run, /var/run, /dev/shm or /dev).
-  #ignore_fs = ["tmpfs", "devtmpfs"]
+# # Read metrics about disk usage by mount point
+# [[inputs.disk]]
+#   ## By default, telegraf gather stats for all mountpoints.
+#   ## Setting mountpoints will restrict the stats to the specified mountpoints.
+#   ## mount_points=["/"]
+#
+#   ## Ignore some mountpoints by filesystem type. For example (dev)tmpfs (usually
+#   ## present on /run, /var/run, /dev/shm or /dev).
+#   # ignore_fs = ["tmpfs", "devtmpfs"]
 
-# Read metrics about disk IO by device
-#[[inputs.diskio]]
-  ## By default, telegraf will gather stats for all devices including
-  ## disk partitions.
-  ## Setting devices will restrict the stats to the specified devices.
-  ## devices = ["sda", "sdb"]
-  ## Uncomment the following line if you do not need disk serial numbers.
-  ## skip_serial_number = true
 
-# Read metrics about memory usage
-#[[inputs.mem]]
-  # no configuration
+# # Read metrics about disk IO by device
+# [[inputs.diskio]]
+#   ## By default, telegraf will gather stats for all devices including
+#   ## disk partitions.
+#   ## Setting devices will restrict the stats to the specified devices.
+#   ## devices = ["sda", "sdb"]
+#   ## Uncomment the following line if you do not need disk serial numbers.
+#   ## skip_serial_number = true
 
-# Read metrics about swap memory usage
-#[[inputs.swap]]
-  # no configuration
+
+# # Read metrics about memory usage
+# [[inputs.mem]]
+#   # no configuration
+
+
+# # Read metrics about swap memory usage
+# [[inputs.swap]]
+#   # no configuration
 

filter/filter.go

@@ -10,16 +10,16 @@ type Filter interface {
 	Match(string) bool
 }
 
-// CompileFilter takes a list of string filters and returns a Filter interface
+// Compile takes a list of string filters and returns a Filter interface
 // for matching a given string against the filter list. The filter list
 // supports glob matching too, ie:
 //
-//   f, _ := CompileFilter([]string{"cpu", "mem", "net*"})
+//   f, _ := Compile([]string{"cpu", "mem", "net*"})
 //   f.Match("cpu")     // true
 //   f.Match("network") // true
 //   f.Match("memory")  // false
 //
-func CompileFilter(filters []string) (Filter, error) {
+func Compile(filters []string) (Filter, error) {
 	// return if there is nothing to compile
 	if len(filters) == 0 {
 		return nil, nil

filter/filter_test.go

@@ -6,30 +6,30 @@ import (
 	"github.com/stretchr/testify/assert"
 )
 
-func TestCompileFilter(t *testing.T) {
-	f, err := CompileFilter([]string{})
+func TestCompile(t *testing.T) {
+	f, err := Compile([]string{})
 	assert.NoError(t, err)
 	assert.Nil(t, f)
 
-	f, err = CompileFilter([]string{"cpu"})
+	f, err = Compile([]string{"cpu"})
 	assert.NoError(t, err)
 	assert.True(t, f.Match("cpu"))
 	assert.False(t, f.Match("cpu0"))
 	assert.False(t, f.Match("mem"))
 
-	f, err = CompileFilter([]string{"cpu*"})
+	f, err = Compile([]string{"cpu*"})
 	assert.NoError(t, err)
 	assert.True(t, f.Match("cpu"))
 	assert.True(t, f.Match("cpu0"))
 	assert.False(t, f.Match("mem"))
 
-	f, err = CompileFilter([]string{"cpu", "mem"})
+	f, err = Compile([]string{"cpu", "mem"})
 	assert.NoError(t, err)
 	assert.True(t, f.Match("cpu"))
 	assert.False(t, f.Match("cpu0"))
 	assert.True(t, f.Match("mem"))
 
-	f, err = CompileFilter([]string{"cpu", "mem", "net*"})
+	f, err = Compile([]string{"cpu", "mem", "net*"})
 	assert.NoError(t, err)
 	assert.True(t, f.Match("cpu"))
 	assert.False(t, f.Match("cpu0"))
@@ -40,7 +40,7 @@ func TestCompileFilter(t *testing.T) {
 var benchbool bool
 
 func BenchmarkFilterSingleNoGlobFalse(b *testing.B) {
-	f, _ := CompileFilter([]string{"cpu"})
+	f, _ := Compile([]string{"cpu"})
 	var tmp bool
 	for n := 0; n < b.N; n++ {
 		tmp = f.Match("network")
@@ -49,7 +49,7 @@ func BenchmarkFilterSingleNoGlobFalse(b *testing.B) {
 }
 
 func BenchmarkFilterSingleNoGlobTrue(b *testing.B) {
-	f, _ := CompileFilter([]string{"cpu"})
+	f, _ := Compile([]string{"cpu"})
 	var tmp bool
 	for n := 0; n < b.N; n++ {
 		tmp = f.Match("cpu")
@@ -58,7 +58,7 @@ func BenchmarkFilterSingleNoGlobTrue(b *testing.B) {
 }
 
 func BenchmarkFilter(b *testing.B) {
-	f, _ := CompileFilter([]string{"cpu", "mem", "net*"})
+	f, _ := Compile([]string{"cpu", "mem", "net*"})
 	var tmp bool
 	for n := 0; n < b.N; n++ {
 		tmp = f.Match("network")
@@ -67,7 +67,7 @@ func BenchmarkFilter(b *testing.B) {
 }
 
 func BenchmarkFilterNoGlob(b *testing.B) {
-	f, _ := CompileFilter([]string{"cpu", "mem", "net"})
+	f, _ := Compile([]string{"cpu", "mem", "net"})
 	var tmp bool
 	for n := 0; n < b.N; n++ {
 		tmp = f.Match("net")
@@ -76,7 +76,7 @@ func BenchmarkFilterNoGlob(b *testing.B) {
 }
 
 func BenchmarkFilter2(b *testing.B) {
-	f, _ := CompileFilter([]string{"aa", "bb", "c", "ad", "ar", "at", "aq",
+	f, _ := Compile([]string{"aa", "bb", "c", "ad", "ar", "at", "aq",
 		"aw", "az", "axxx", "ab", "cpu", "mem", "net*"})
 	var tmp bool
 	for n := 0; n < b.N; n++ {
@@ -86,7 +86,7 @@ func BenchmarkFilter2(b *testing.B) {
 }
 
 func BenchmarkFilter2NoGlob(b *testing.B) {
-	f, _ := CompileFilter([]string{"aa", "bb", "c", "ad", "ar", "at", "aq",
+	f, _ := Compile([]string{"aa", "bb", "c", "ad", "ar", "at", "aq",
 		"aw", "az", "axxx", "ab", "cpu", "mem", "net"})
 	var tmp bool
 	for n := 0; n < b.N; n++ {

internal/config/config.go

@@ -125,6 +125,9 @@ type AgentConfig struct {
 	// Debug is the option for running in debug mode
 	Debug bool
 
+	// Logfile specifies the file to send logs to
+	Logfile string
+
 	// Quiet is the option for running in quiet mode
 	Quiet        bool
 	Hostname     string
@@ -195,12 +198,15 @@ var header = `# Telegraf Configuration
   ## ie, if interval="10s" then always collect on :00, :10, :20, etc.
   round_interval = true
 
-  ## Telegraf will send metrics to outputs in batches of at
-  ## most metric_batch_size metrics.
+  ## Telegraf will send metrics to outputs in batches of at most
+  ## metric_batch_size metrics.
+  ## This controls the size of writes that Telegraf sends to output plugins.
   metric_batch_size = 1000
+
   ## For failed writes, telegraf will cache metric_buffer_limit metrics for each
   ## output, and will flush this buffer on a successful write. Oldest metrics
   ## are dropped first when this buffer fills.
+  ## This buffer only fills when writes fail to output plugin(s).
   metric_buffer_limit = 10000
 
   ## Collection jitter is used to jitter the collection by a random amount.
@@ -222,10 +228,15 @@ var header = `# Telegraf Configuration
   ## Precision will NOT be used for service inputs, such as logparser and statsd.
   ## Valid values are "ns", "us" (or "µs"), "ms", "s".
   precision = ""
-  ## Run telegraf in debug mode
+
+  ## Logging configuration:
+  ## Run telegraf with debug log messages.
   debug = false
-  ## Run telegraf in quiet mode
+  ## Run telegraf in quiet mode (error log messages only).
   quiet = false
+  ## Specify the log file name. The empty string means to log to stdout.
+  logfile = ""
+
   ## Override default hostname, if empty use os.Hostname()
   hostname = ""
   ## If set to true, do no set the "host" tag in the telegraf agent.
@@ -404,24 +415,21 @@ func PrintOutputConfig(name string) error {
 }
 
 func (c *Config) LoadDirectory(path string) error {
-	directoryEntries, err := ioutil.ReadDir(path)
-	if err != nil {
-		return err
-	}
-	for _, entry := range directoryEntries {
-		if entry.IsDir() {
-			continue
+	walkfn := func(thispath string, info os.FileInfo, _ error) error {
+		if info.IsDir() {
+			return nil
 		}
-		name := entry.Name()
+		name := info.Name()
 		if len(name) < 6 || name[len(name)-5:] != ".conf" {
-			continue
+			return nil
 		}
-		err := c.LoadConfig(filepath.Join(path, name))
+		err := c.LoadConfig(thispath)
 		if err != nil {
 			return err
 		}
+		return nil
 	}
-	return nil
+	return filepath.Walk(path, walkfn)
 }
 
 // Try to find a default config file at these locations (in order):
@@ -438,7 +446,7 @@ func getDefaultConfigPath() (string, error) {
 	}
 	for _, path := range []string{envfile, homefile, etcfile} {
 		if _, err := os.Stat(path); err == nil {
-			log.Printf("Using config file: %s", path)
+			log.Printf("I! Using config file: %s", path)
 			return path, nil
 		}
 	}
@@ -469,7 +477,7 @@ func (c *Config) LoadConfig(path string) error {
 				return fmt.Errorf("%s: invalid configuration", path)
 			}
 			if err = config.UnmarshalTable(subTable, c.Tags); err != nil {
-				log.Printf("Could not parse [global_tags] config\n")
+				log.Printf("E! Could not parse [global_tags] config\n")
 				return fmt.Errorf("Error parsing %s, %s", path, err)
 			}
 		}
@@ -482,7 +490,7 @@ func (c *Config) LoadConfig(path string) error {
 			return fmt.Errorf("%s: invalid configuration", path)
 		}
 		if err = config.UnmarshalTable(subTable, c.Agent); err != nil {
-			log.Printf("Could not parse [agent] config\n")
+			log.Printf("E! Could not parse [agent] config\n")
 			return fmt.Errorf("Error parsing %s, %s", path, err)
 		}
 	}
@@ -665,7 +673,6 @@ func buildFilter(tbl *ast.Table) (models.Filter, error) {
 				for _, elem := range ary.Value {
 					if str, ok := elem.(*ast.String); ok {
 						f.NamePass = append(f.NamePass, str.Value)
-						f.IsActive = true
 					}
 				}
 			}
@@ -678,7 +685,6 @@ func buildFilter(tbl *ast.Table) (models.Filter, error) {
 				for _, elem := range ary.Value {
 					if str, ok := elem.(*ast.String); ok {
 						f.NameDrop = append(f.NameDrop, str.Value)
-						f.IsActive = true
 					}
 				}
 			}
@@ -693,7 +699,6 @@ func buildFilter(tbl *ast.Table) (models.Filter, error) {
 					for _, elem := range ary.Value {
 						if str, ok := elem.(*ast.String); ok {
 							f.FieldPass = append(f.FieldPass, str.Value)
-							f.IsActive = true
 						}
 					}
 				}
@@ -709,7 +714,6 @@ func buildFilter(tbl *ast.Table) (models.Filter, error) {
 					for _, elem := range ary.Value {
 						if str, ok := elem.(*ast.String); ok {
 							f.FieldDrop = append(f.FieldDrop, str.Value)
-							f.IsActive = true
 						}
 					}
 				}
@@ -730,7 +734,6 @@ func buildFilter(tbl *ast.Table) (models.Filter, error) {
 						}
 					}
 					f.TagPass = append(f.TagPass, *tagfilter)
-					f.IsActive = true
 				}
 			}
 		}
@@ -749,7 +752,6 @@ func buildFilter(tbl *ast.Table) (models.Filter, error) {
 						}
 					}
 					f.TagDrop = append(f.TagDrop, *tagfilter)
-					f.IsActive = true
 				}
 			}
 		}
@@ -778,7 +780,7 @@ func buildFilter(tbl *ast.Table) (models.Filter, error) {
 			}
 		}
 	}
-	if err := f.CompileFilter(); err != nil {
+	if err := f.Compile(); err != nil {
 		return f, err
 	}
 
@@ -841,7 +843,7 @@ func buildInput(name string, tbl *ast.Table) (*models.InputConfig, error) {
 	if node, ok := tbl.Fields["tags"]; ok {
 		if subtbl, ok := node.(*ast.Table); ok {
 			if err := config.UnmarshalTable(subtbl, cp.Tags); err != nil {
-				log.Printf("Could not parse tags for input %s\n", name)
+				log.Printf("E! Could not parse tags for input %s\n", name)
 			}
 		}
 	}

internal/config/config_test.go

@@ -43,9 +43,8 @@ func TestConfig_LoadSingleInputWithEnvVars(t *testing.T) {
 				Filter: []string{"mytag"},
 			},
 		},
-		IsActive: true,
 	}
-	assert.NoError(t, filter.CompileFilter())
+	assert.NoError(t, filter.Compile())
 	mConfig := &models.InputConfig{
 		Name:     "memcached",
 		Filter:   filter,
@@ -83,9 +82,8 @@ func TestConfig_LoadSingleInput(t *testing.T) {
 				Filter: []string{"mytag"},
 			},
 		},
-		IsActive: true,
 	}
-	assert.NoError(t, filter.CompileFilter())
+	assert.NoError(t, filter.Compile())
 	mConfig := &models.InputConfig{
 		Name:     "memcached",
 		Filter:   filter,
@@ -130,9 +128,8 @@ func TestConfig_LoadDirectory(t *testing.T) {
 				Filter: []string{"mytag"},
 			},
 		},
-		IsActive: true,
 	}
-	assert.NoError(t, filter.CompileFilter())
+	assert.NoError(t, filter.Compile())
 	mConfig := &models.InputConfig{
 		Name:     "memcached",
 		Filter:   filter,

internal/globpath/globpath.go

@@ -12,21 +12,23 @@ import (
 var sepStr = fmt.Sprintf("%v", string(os.PathSeparator))
 
 type GlobPath struct {
-	path    string
-	hasMeta bool
-	g       glob.Glob
-	root    string
+	path         string
+	hasMeta      bool
+	hasSuperMeta bool
+	g            glob.Glob
+	root         string
 }
 
 func Compile(path string) (*GlobPath, error) {
 	out := GlobPath{
-		hasMeta: hasMeta(path),
-		path:    path,
+		hasMeta:      hasMeta(path),
+		hasSuperMeta: hasSuperMeta(path),
+		path:         path,
 	}
 
 	// if there are no glob meta characters in the path, don't bother compiling
 	// a glob object or finding the root directory. (see short-circuit in Match)
-	if !out.hasMeta {
+	if !out.hasMeta || !out.hasSuperMeta {
 		return &out, nil
 	}
 
@@ -48,6 +50,17 @@ func (g *GlobPath) Match() map[string]os.FileInfo {
 		}
 		return out
 	}
+	if !g.hasSuperMeta {
+		out := make(map[string]os.FileInfo)
+		files, _ := filepath.Glob(g.path)
+		for _, file := range files {
+			info, err := os.Stat(file)
+			if !os.IsNotExist(err) {
+				out[file] = info
+			}
+		}
+		return out
+	}
 	return walkFilePath(g.root, g.g)
 }
 
@@ -96,3 +109,8 @@ func findRootDir(path string) string {
 func hasMeta(path string) bool {
 	return strings.IndexAny(path, "*?[") >= 0
 }
+
+// hasSuperMeta reports whether path contains any super magic glob characters (**).
+func hasSuperMeta(path string) bool {
+	return strings.Index(path, "**") >= 0
+}

internal/internal.go

@@ -198,7 +198,7 @@ func WaitTimeout(c *exec.Cmd, timeout time.Duration) error {
 		return err
 	case <-timer.C:
 		if err := c.Process.Kill(); err != nil {
-			log.Printf("FATAL error killing process: %s", err)
+			log.Printf("E! FATAL error killing process: %s", err)
 			return err
 		}
 		// wait for the command to return after killing it

internal/internal_test.go

@@ -118,7 +118,7 @@ func TestRandomSleep(t *testing.T) {
 	s = time.Now()
 	RandomSleep(time.Millisecond*50, make(chan struct{}))
 	elapsed = time.Since(s)
-	assert.True(t, elapsed < time.Millisecond*50)
+	assert.True(t, elapsed < time.Millisecond*100)
 
 	// test that shutdown is respected
 	s = time.Now()

internal/models/filter.go

@@ -3,7 +3,6 @@ package models
 import (
 	"fmt"
 
-	"github.com/influxdata/telegraf"
 	"github.com/influxdata/telegraf/filter"
 )
 
@@ -34,47 +33,59 @@ type Filter struct {
 	TagInclude []string
 	tagInclude filter.Filter
 
-	IsActive bool
+	isActive bool
 }
 
 // Compile all Filter lists into filter.Filter objects.
-func (f *Filter) CompileFilter() error {
+func (f *Filter) Compile() error {
+	if len(f.NameDrop) == 0 &&
+		len(f.NamePass) == 0 &&
+		len(f.FieldDrop) == 0 &&
+		len(f.FieldPass) == 0 &&
+		len(f.TagInclude) == 0 &&
+		len(f.TagExclude) == 0 &&
+		len(f.TagPass) == 0 &&
+		len(f.TagDrop) == 0 {
+		return nil
+	}
+
+	f.isActive = true
 	var err error
-	f.nameDrop, err = filter.CompileFilter(f.NameDrop)
+	f.nameDrop, err = filter.Compile(f.NameDrop)
 	if err != nil {
 		return fmt.Errorf("Error compiling 'namedrop', %s", err)
 	}
-	f.namePass, err = filter.CompileFilter(f.NamePass)
+	f.namePass, err = filter.Compile(f.NamePass)
 	if err != nil {
 		return fmt.Errorf("Error compiling 'namepass', %s", err)
 	}
 
-	f.fieldDrop, err = filter.CompileFilter(f.FieldDrop)
+	f.fieldDrop, err = filter.Compile(f.FieldDrop)
 	if err != nil {
 		return fmt.Errorf("Error compiling 'fielddrop', %s", err)
 	}
-	f.fieldPass, err = filter.CompileFilter(f.FieldPass)
+	f.fieldPass, err = filter.Compile(f.FieldPass)
 	if err != nil {
 		return fmt.Errorf("Error compiling 'fieldpass', %s", err)
 	}
 
-	f.tagExclude, err = filter.CompileFilter(f.TagExclude)
+	f.tagExclude, err = filter.Compile(f.TagExclude)
 	if err != nil {
 		return fmt.Errorf("Error compiling 'tagexclude', %s", err)
 	}
-	f.tagInclude, err = filter.CompileFilter(f.TagInclude)
+	f.tagInclude, err = filter.Compile(f.TagInclude)
 	if err != nil {
 		return fmt.Errorf("Error compiling 'taginclude', %s", err)
 	}
 
 	for i, _ := range f.TagDrop {
-		f.TagDrop[i].filter, err = filter.CompileFilter(f.TagDrop[i].Filter)
+		f.TagDrop[i].filter, err = filter.Compile(f.TagDrop[i].Filter)
 		if err != nil {
 			return fmt.Errorf("Error compiling 'tagdrop', %s", err)
 		}
 	}
 	for i, _ := range f.TagPass {
-		f.TagPass[i].filter, err = filter.CompileFilter(f.TagPass[i].Filter)
+		f.TagPass[i].filter, err = filter.Compile(f.TagPass[i].Filter)
 		if err != nil {
 			return fmt.Errorf("Error compiling 'tagpass', %s", err)
 		}
@@ -82,16 +93,52 @@ func (f *Filter) CompileFilter() error {
 	return nil
 }
 
-func (f *Filter) ShouldMetricPass(metric telegraf.Metric) bool {
-	if f.ShouldNamePass(metric.Name()) && f.ShouldTagsPass(metric.Tags()) {
+// Apply applies the filter to the given measurement name, fields map, and
+// tags map. It will return false if the metric should be "filtered out", and
+// true if the metric should "pass".
+// It will modify tags in-place if they need to be deleted.
+func (f *Filter) Apply(
+	measurement string,
+	fields map[string]interface{},
+	tags map[string]string,
+) bool {
+	if !f.isActive {
 		return true
 	}
-	return false
+
+	// check if the measurement name should pass
+	if !f.shouldNamePass(measurement) {
+		return false
+	}
+
+	// check if the tags should pass
+	if !f.shouldTagsPass(tags) {
+		return false
+	}
+
+	// filter fields
+	for fieldkey, _ := range fields {
+		if !f.shouldFieldPass(fieldkey) {
+			delete(fields, fieldkey)
+		}
+	}
+	if len(fields) == 0 {
+		return false
+	}
+
+	// filter tags
+	f.filterTags(tags)
+
+	return true
 }
 
-// ShouldFieldsPass returns true if the metric should pass, false if should drop
+func (f *Filter) IsActive() bool {
+	return f.isActive
+}
+
+// shouldNamePass returns true if the metric should pass, false if should drop
 // based on the drop/pass filter parameters
-func (f *Filter) ShouldNamePass(key string) bool {
+func (f *Filter) shouldNamePass(key string) bool {
 	if f.namePass != nil {
 		if f.namePass.Match(key) {
 			return true
@@ -107,9 +154,9 @@ func (f *Filter) ShouldNamePass(key string) bool {
 	return true
 }
 
-// ShouldFieldsPass returns true if the metric should pass, false if should drop
+// shouldFieldPass returns true if the metric should pass, false if should drop
 // based on the drop/pass filter parameters
-func (f *Filter) ShouldFieldsPass(key string) bool {
+func (f *Filter) shouldFieldPass(key string) bool {
 	if f.fieldPass != nil {
 		if f.fieldPass.Match(key) {
 			return true
@@ -125,9 +172,9 @@ func (f *Filter) ShouldFieldsPass(key string) bool {
 	return true
 }
 
-// ShouldTagsPass returns true if the metric should pass, false if should drop
+// shouldTagsPass returns true if the metric should pass, false if should drop
 // based on the tagdrop/tagpass filter parameters
-func (f *Filter) ShouldTagsPass(tags map[string]string) bool {
+func (f *Filter) shouldTagsPass(tags map[string]string) bool {
 	if f.TagPass != nil {
 		for _, pat := range f.TagPass {
 			if pat.filter == nil {
@@ -161,7 +208,7 @@ func (f *Filter) ShouldTagsPass(tags map[string]string) bool {
 
 // Apply TagInclude and TagExclude filters.
 // modifies the tags map in-place.
-func (f *Filter) FilterTags(tags map[string]string) {
+func (f *Filter) filterTags(tags map[string]string) {
 	if f.tagInclude != nil {
 		for k, _ := range tags {
 			if !f.tagInclude.Match(k) {

internal/models/filter_test.go

@@ -3,12 +3,62 @@ package models
 import (
 	"testing"
 
-	"github.com/influxdata/telegraf/testutil"
-
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )
 
+func TestFilter_ApplyEmpty(t *testing.T) {
+	f := Filter{}
+	require.NoError(t, f.Compile())
+	assert.False(t, f.IsActive())
+
+	assert.True(t, f.Apply("m", map[string]interface{}{"value": int64(1)}, map[string]string{}))
+}
+
+func TestFilter_ApplyTagsDontPass(t *testing.T) {
+	filters := []TagFilter{
+		TagFilter{
+			Name:   "cpu",
+			Filter: []string{"cpu-*"},
+		},
+	}
+	f := Filter{
+		TagDrop: filters,
+	}
+	require.NoError(t, f.Compile())
+	require.NoError(t, f.Compile())
+	assert.True(t, f.IsActive())
+
+	assert.False(t, f.Apply("m",
+		map[string]interface{}{"value": int64(1)},
+		map[string]string{"cpu": "cpu-total"}))
+}
+
+func TestFilter_ApplyDeleteFields(t *testing.T) {
+	f := Filter{
+		FieldDrop: []string{"value"},
+	}
+	require.NoError(t, f.Compile())
+	require.NoError(t, f.Compile())
+	assert.True(t, f.IsActive())
+
+	fields := map[string]interface{}{"value": int64(1), "value2": int64(2)}
+	assert.True(t, f.Apply("m", fields, nil))
+	assert.Equal(t, map[string]interface{}{"value2": int64(2)}, fields)
+}
+
+func TestFilter_ApplyDeleteAllFields(t *testing.T) {
+	f := Filter{
+		FieldDrop: []string{"value*"},
+	}
+	require.NoError(t, f.Compile())
+	require.NoError(t, f.Compile())
+	assert.True(t, f.IsActive())
+
+	fields := map[string]interface{}{"value": int64(1), "value2": int64(2)}
+	assert.False(t, f.Apply("m", fields, nil))
+}
+
 func TestFilter_Empty(t *testing.T) {
 	f := Filter{}
 
@@ -23,7 +73,7 @@ func TestFilter_Empty(t *testing.T) {
 	}
 
 	for _, measurement := range measurements {
-		if !f.ShouldFieldsPass(measurement) {
+		if !f.shouldFieldPass(measurement) {
 			t.Errorf("Expected measurement %s to pass", measurement)
 		}
 	}
@@ -33,7 +83,7 @@ func TestFilter_NamePass(t *testing.T) {
 	f := Filter{
 		NamePass: []string{"foo*", "cpu_usage_idle"},
 	}
-	require.NoError(t, f.CompileFilter())
+	require.NoError(t, f.Compile())
 
 	passes := []string{
 		"foo",
@@ -51,13 +101,13 @@ func TestFilter_NamePass(t *testing.T) {
 	}
 
 	for _, measurement := range passes {
-		if !f.ShouldNamePass(measurement) {
+		if !f.shouldNamePass(measurement) {
 			t.Errorf("Expected measurement %s to pass", measurement)
 		}
 	}
 
 	for _, measurement := range drops {
-		if f.ShouldNamePass(measurement) {
+		if f.shouldNamePass(measurement) {
 			t.Errorf("Expected measurement %s to drop", measurement)
 		}
 	}
@@ -67,7 +117,7 @@ func TestFilter_NameDrop(t *testing.T) {
 	f := Filter{
 		NameDrop: []string{"foo*", "cpu_usage_idle"},
 	}
-	require.NoError(t, f.CompileFilter())
+	require.NoError(t, f.Compile())
 
 	drops := []string{
 		"foo",
@@ -85,13 +135,13 @@ func TestFilter_NameDrop(t *testing.T) {
 	}
 
 	for _, measurement := range passes {
-		if !f.ShouldNamePass(measurement) {
+		if !f.shouldNamePass(measurement) {
 			t.Errorf("Expected measurement %s to pass", measurement)
 		}
 	}
 
 	for _, measurement := range drops {
-		if f.ShouldNamePass(measurement) {
+		if f.shouldNamePass(measurement) {
 			t.Errorf("Expected measurement %s to drop", measurement)
 		}
 	}
@@ -101,7 +151,7 @@ func TestFilter_FieldPass(t *testing.T) {
 	f := Filter{
 		FieldPass: []string{"foo*", "cpu_usage_idle"},
 	}
-	require.NoError(t, f.CompileFilter())
+	require.NoError(t, f.Compile())
 
 	passes := []string{
 		"foo",
@@ -119,13 +169,13 @@ func TestFilter_FieldPass(t *testing.T) {
 	}
 
 	for _, measurement := range passes {
-		if !f.ShouldFieldsPass(measurement) {
+		if !f.shouldFieldPass(measurement) {
 			t.Errorf("Expected measurement %s to pass", measurement)
 		}
 	}
 
 	for _, measurement := range drops {
-		if f.ShouldFieldsPass(measurement) {
+		if f.shouldFieldPass(measurement) {
 			t.Errorf("Expected measurement %s to drop", measurement)
 		}
 	}
@@ -135,7 +185,7 @@ func TestFilter_FieldDrop(t *testing.T) {
 	f := Filter{
 		FieldDrop: []string{"foo*", "cpu_usage_idle"},
 	}
-	require.NoError(t, f.CompileFilter())
+	require.NoError(t, f.Compile())
 
 	drops := []string{
 		"foo",
@@ -153,13 +203,13 @@ func TestFilter_FieldDrop(t *testing.T) {
 	}
 
 	for _, measurement := range passes {
-		if !f.ShouldFieldsPass(measurement) {
+		if !f.shouldFieldPass(measurement) {
 			t.Errorf("Expected measurement %s to pass", measurement)
 		}
 	}
 
 	for _, measurement := range drops {
-		if f.ShouldFieldsPass(measurement) {
+		if f.shouldFieldPass(measurement) {
 			t.Errorf("Expected measurement %s to drop", measurement)
 		}
 	}
@@ -178,7 +228,7 @@ func TestFilter_TagPass(t *testing.T) {
 	f := Filter{
 		TagPass: filters,
 	}
-	require.NoError(t, f.CompileFilter())
+	require.NoError(t, f.Compile())
 
 	passes := []map[string]string{
 		{"cpu": "cpu-total"},
@@ -197,13 +247,13 @@ func TestFilter_TagPass(t *testing.T) {
 	}
 
 	for _, tags := range passes {
-		if !f.ShouldTagsPass(tags) {
+		if !f.shouldTagsPass(tags) {
 			t.Errorf("Expected tags %v to pass", tags)
 		}
 	}
 
 	for _, tags := range drops {
-		if f.ShouldTagsPass(tags) {
+		if f.shouldTagsPass(tags) {
 			t.Errorf("Expected tags %v to drop", tags)
 		}
 	}
@@ -222,7 +272,7 @@ func TestFilter_TagDrop(t *testing.T) {
 	f := Filter{
 		TagDrop: filters,
 	}
-	require.NoError(t, f.CompileFilter())
+	require.NoError(t, f.Compile())
 
 	drops := []map[string]string{
 		{"cpu": "cpu-total"},
@@ -241,30 +291,18 @@ func TestFilter_TagDrop(t *testing.T) {
 	}
 
 	for _, tags := range passes {
-		if !f.ShouldTagsPass(tags) {
+		if !f.shouldTagsPass(tags) {
 			t.Errorf("Expected tags %v to pass", tags)
 		}
 	}
 
 	for _, tags := range drops {
-		if f.ShouldTagsPass(tags) {
+		if f.shouldTagsPass(tags) {
 			t.Errorf("Expected tags %v to drop", tags)
 		}
 	}
 }
 
-func TestFilter_ShouldMetricsPass(t *testing.T) {
-	m := testutil.TestMetric(1, "testmetric")
-	f := Filter{
-		NameDrop: []string{"foobar"},
-	}
-	require.NoError(t, f.CompileFilter())
-	require.True(t, f.ShouldMetricPass(m))
-
-	m = testutil.TestMetric(1, "foobar")
-	require.False(t, f.ShouldMetricPass(m))
-}
-
 func TestFilter_FilterTagsNoMatches(t *testing.T) {
 	pretags := map[string]string{
 		"host":  "localhost",
@@ -273,9 +311,9 @@ func TestFilter_FilterTagsNoMatches(t *testing.T) {
 	f := Filter{
 		TagExclude: []string{"nomatch"},
 	}
-	require.NoError(t, f.CompileFilter())
+	require.NoError(t, f.Compile())
 
-	f.FilterTags(pretags)
+	f.filterTags(pretags)
 	assert.Equal(t, map[string]string{
 		"host":  "localhost",
 		"mytag": "foobar",
@@ -284,9 +322,9 @@ func TestFilter_FilterTagsNoMatches(t *testing.T) {
 	f = Filter{
 		TagInclude: []string{"nomatch"},
 	}
-	require.NoError(t, f.CompileFilter())
+	require.NoError(t, f.Compile())
 
-	f.FilterTags(pretags)
+	f.filterTags(pretags)
 	assert.Equal(t, map[string]string{}, pretags)
 }
 
@@ -298,9 +336,9 @@ func TestFilter_FilterTagsMatches(t *testing.T) {
 	f := Filter{
 		TagExclude: []string{"ho*"},
 	}
-	require.NoError(t, f.CompileFilter())
+	require.NoError(t, f.Compile())
 
-	f.FilterTags(pretags)
+	f.filterTags(pretags)
 	assert.Equal(t, map[string]string{
 		"mytag": "foobar",
 	}, pretags)
@@ -312,9 +350,9 @@ func TestFilter_FilterTagsMatches(t *testing.T) {
 	f = Filter{
 		TagInclude: []string{"my*"},
 	}
-	require.NoError(t, f.CompileFilter())
+	require.NoError(t, f.Compile())
 
-	f.FilterTags(pretags)
+	f.filterTags(pretags)
 	assert.Equal(t, map[string]string{
 		"mytag": "foobar",
 	}, pretags)

internal/models/running_output.go

@@ -57,21 +57,17 @@ func NewRunningOutput(
 // AddMetric adds a metric to the output. This function can also write cached
 // points if FlushBufferWhenFull is true.
 func (ro *RunningOutput) AddMetric(metric telegraf.Metric) {
-	if ro.Config.Filter.IsActive {
-		if !ro.Config.Filter.ShouldMetricPass(metric) {
-			return
-		}
-	}
-
 	// Filter any tagexclude/taginclude parameters before adding metric
-	if len(ro.Config.Filter.TagExclude) != 0 || len(ro.Config.Filter.TagInclude) != 0 {
+	if ro.Config.Filter.IsActive() {
 		// In order to filter out tags, we need to create a new metric, since
 		// metrics are immutable once created.
+		name := metric.Name()
 		tags := metric.Tags()
 		fields := metric.Fields()
 		t := metric.Time()
-		name := metric.Name()
-		ro.Config.Filter.FilterTags(tags)
+		if ok := ro.Config.Filter.Apply(name, fields, tags); !ok {
+			return
+		}
 		// error is not possible if creating from another metric, so ignore.
 		metric, _ = telegraf.NewMetric(name, tags, fields, t)
 	}
@@ -89,7 +85,7 @@ func (ro *RunningOutput) AddMetric(metric telegraf.Metric) {
 // Write writes all cached points to this output.
 func (ro *RunningOutput) Write() error {
 	if !ro.Quiet {
-		log.Printf("Output [%s] buffer fullness: %d / %d metrics. "+
+		log.Printf("I! Output [%s] buffer fullness: %d / %d metrics. "+
 			"Total gathered metrics: %d. Total dropped metrics: %d.",
 			ro.Name,
 			ro.failMetrics.Len()+ro.metrics.Len(),
@@ -146,7 +142,7 @@ func (ro *RunningOutput) write(metrics []telegraf.Metric) error {
 	elapsed := time.Since(start)
 	if err == nil {
 		if !ro.Quiet {
-			log.Printf("Output [%s] wrote batch of %d metrics in %s\n",
+			log.Printf("I! Output [%s] wrote batch of %d metrics in %s\n",
 				ro.Name, len(metrics), elapsed)
 		}
 	}

internal/models/running_output_test.go

@@ -31,9 +31,7 @@ var next5 = []telegraf.Metric{
 // Benchmark adding metrics.
 func BenchmarkRunningOutputAddWrite(b *testing.B) {
 	conf := &OutputConfig{
-		Filter: Filter{
-			IsActive: false,
-		},
+		Filter: Filter{},
 	}
 
 	m := &perfOutput{}
@@ -49,9 +47,7 @@ func BenchmarkRunningOutputAddWrite(b *testing.B) {
 // Benchmark adding metrics.
 func BenchmarkRunningOutputAddWriteEvery100(b *testing.B) {
 	conf := &OutputConfig{
-		Filter: Filter{
-			IsActive: false,
-		},
+		Filter: Filter{},
 	}
 
 	m := &perfOutput{}
@@ -69,9 +65,7 @@ func BenchmarkRunningOutputAddWriteEvery100(b *testing.B) {
 // Benchmark adding metrics.
 func BenchmarkRunningOutputAddFailWrites(b *testing.B) {
 	conf := &OutputConfig{
-		Filter: Filter{
-			IsActive: false,
-		},
+		Filter: Filter{},
 	}
 
 	m := &perfOutput{}
@@ -88,11 +82,10 @@ func BenchmarkRunningOutputAddFailWrites(b *testing.B) {
 func TestRunningOutput_DropFilter(t *testing.T) {
 	conf := &OutputConfig{
 		Filter: Filter{
-			IsActive: true,
 			NameDrop: []string{"metric1", "metric2"},
 		},
 	}
-	assert.NoError(t, conf.Filter.CompileFilter())
+	assert.NoError(t, conf.Filter.Compile())
 
 	m := &mockOutput{}
 	ro := NewRunningOutput("test", m, conf, 1000, 10000)
@@ -114,11 +107,10 @@ func TestRunningOutput_DropFilter(t *testing.T) {
 func TestRunningOutput_PassFilter(t *testing.T) {
 	conf := &OutputConfig{
 		Filter: Filter{
-			IsActive: true,
 			NameDrop: []string{"metric1000", "foo*"},
 		},
 	}
-	assert.NoError(t, conf.Filter.CompileFilter())
+	assert.NoError(t, conf.Filter.Compile())
 
 	m := &mockOutput{}
 	ro := NewRunningOutput("test", m, conf, 1000, 10000)
@@ -140,11 +132,11 @@ func TestRunningOutput_PassFilter(t *testing.T) {
 func TestRunningOutput_TagIncludeNoMatch(t *testing.T) {
 	conf := &OutputConfig{
 		Filter: Filter{
-			IsActive:   true,
+
 			TagInclude: []string{"nothing*"},
 		},
 	}
-	assert.NoError(t, conf.Filter.CompileFilter())
+	assert.NoError(t, conf.Filter.Compile())
 
 	m := &mockOutput{}
 	ro := NewRunningOutput("test", m, conf, 1000, 10000)
@@ -162,11 +154,11 @@ func TestRunningOutput_TagIncludeNoMatch(t *testing.T) {
 func TestRunningOutput_TagExcludeMatch(t *testing.T) {
 	conf := &OutputConfig{
 		Filter: Filter{
-			IsActive:   true,
+
 			TagExclude: []string{"tag*"},
 		},
 	}
-	assert.NoError(t, conf.Filter.CompileFilter())
+	assert.NoError(t, conf.Filter.Compile())
 
 	m := &mockOutput{}
 	ro := NewRunningOutput("test", m, conf, 1000, 10000)
@@ -184,11 +176,11 @@ func TestRunningOutput_TagExcludeMatch(t *testing.T) {
 func TestRunningOutput_TagExcludeNoMatch(t *testing.T) {
 	conf := &OutputConfig{
 		Filter: Filter{
-			IsActive:   true,
+
 			TagExclude: []string{"nothing*"},
 		},
 	}
-	assert.NoError(t, conf.Filter.CompileFilter())
+	assert.NoError(t, conf.Filter.Compile())
 
 	m := &mockOutput{}
 	ro := NewRunningOutput("test", m, conf, 1000, 10000)
@@ -206,11 +198,11 @@ func TestRunningOutput_TagExcludeNoMatch(t *testing.T) {
 func TestRunningOutput_TagIncludeMatch(t *testing.T) {
 	conf := &OutputConfig{
 		Filter: Filter{
-			IsActive:   true,
+
 			TagInclude: []string{"tag*"},
 		},
 	}
-	assert.NoError(t, conf.Filter.CompileFilter())
+	assert.NoError(t, conf.Filter.Compile())
 
 	m := &mockOutput{}
 	ro := NewRunningOutput("test", m, conf, 1000, 10000)
@@ -227,9 +219,7 @@ func TestRunningOutput_TagIncludeMatch(t *testing.T) {
 // Test that we can write metrics with simple default setup.
 func TestRunningOutputDefault(t *testing.T) {
 	conf := &OutputConfig{
-		Filter: Filter{
-			IsActive: false,
-		},
+		Filter: Filter{},
 	}
 
 	m := &mockOutput{}
@@ -252,9 +242,7 @@ func TestRunningOutputDefault(t *testing.T) {
 // FlushBufferWhenFull is set.
 func TestRunningOutputFlushWhenFull(t *testing.T) {
 	conf := &OutputConfig{
-		Filter: Filter{
-			IsActive: false,
-		},
+		Filter: Filter{},
 	}
 
 	m := &mockOutput{}
@@ -283,9 +271,7 @@ func TestRunningOutputFlushWhenFull(t *testing.T) {
 // FlushBufferWhenFull is set, twice.
 func TestRunningOutputMultiFlushWhenFull(t *testing.T) {
 	conf := &OutputConfig{
-		Filter: Filter{
-			IsActive: false,
-		},
+		Filter: Filter{},
 	}
 
 	m := &mockOutput{}
@@ -304,9 +290,7 @@ func TestRunningOutputMultiFlushWhenFull(t *testing.T) {
 
 func TestRunningOutputWriteFail(t *testing.T) {
 	conf := &OutputConfig{
-		Filter: Filter{
-			IsActive: false,
-		},
+		Filter: Filter{},
 	}
 
 	m := &mockOutput{}
@@ -339,9 +323,7 @@ func TestRunningOutputWriteFail(t *testing.T) {
 // Verify that the order of points is preserved during a write failure.
 func TestRunningOutputWriteFailOrder(t *testing.T) {
 	conf := &OutputConfig{
-		Filter: Filter{
-			IsActive: false,
-		},
+		Filter: Filter{},
 	}
 
 	m := &mockOutput{}
@@ -379,9 +361,7 @@ func TestRunningOutputWriteFailOrder(t *testing.T) {
 // Verify that the order of points is preserved during many write failures.
 func TestRunningOutputWriteFailOrder2(t *testing.T) {
 	conf := &OutputConfig{
-		Filter: Filter{
-			IsActive: false,
-		},
+		Filter: Filter{},
 	}
 
 	m := &mockOutput{}
@@ -452,9 +432,7 @@ func TestRunningOutputWriteFailOrder2(t *testing.T) {
 //
 func TestRunningOutputWriteFailOrder3(t *testing.T) {
 	conf := &OutputConfig{
-		Filter: Filter{
-			IsActive: false,
-		},
+		Filter: Filter{},
 	}
 
 	m := &mockOutput{}

logger/logger.go

@@ -0,0 +1,58 @@
+package logger
+
+import (
+	"io"
+	"log"
+	"os"
+
+	"github.com/influxdata/wlog"
+)
+
+// newTelegrafWriter returns a logging-wrapped writer.
+func newTelegrafWriter(w io.Writer) io.Writer {
+	return &telegrafLog{
+		writer: wlog.NewWriter(w),
+	}
+}
+
+type telegrafLog struct {
+	writer io.Writer
+}
+
+func (t *telegrafLog) Write(p []byte) (n int, err error) {
+	return t.writer.Write(p)
+}
+
+// SetupLogging configures the logging output.
+//   debug   will set the log level to DEBUG
+//   quiet   will set the log level to ERROR
+//   logfile will direct the logging output to a file. Empty string is
+//           interpreted as stdout. If there is an error opening the file the
+//           logger will fallback to stdout.
+func SetupLogging(debug, quiet bool, logfile string) {
+	if debug {
+		wlog.SetLevel(wlog.DEBUG)
+	}
+	if quiet {
+		wlog.SetLevel(wlog.ERROR)
+	}
+
+	var oFile *os.File
+	if logfile != "" {
+		if _, err := os.Stat(logfile); os.IsNotExist(err) {
+			if oFile, err = os.Create(logfile); err != nil {
+				log.Printf("E! Unable to create %s (%s), using stdout", logfile, err)
+				oFile = os.Stdout
+			}
+		} else {
+			if oFile, err = os.OpenFile(logfile, os.O_APPEND|os.O_WRONLY, os.ModeAppend); err != nil {
+				log.Printf("E! Unable to append to %s (%s), using stdout", logfile, err)
+				oFile = os.Stdout
+			}
+		}
+	} else {
+		oFile = os.Stdout
+	}
+
+	log.SetOutput(newTelegrafWriter(oFile))
+}

metric.go

@@ -6,6 +6,17 @@ import (
 	"github.com/influxdata/influxdb/client/v2"
 )
 
+// ValueType is an enumeration of metric types that represent a simple value.
+type ValueType int
+
+// Possible values for the ValueType enum.
+const (
+	_ ValueType = iota
+	Counter
+	Gauge
+	Untyped
+)
+
 type Metric interface {
 	// Name returns the measurement name of the metric
 	Name() string
@@ -16,6 +27,9 @@ type Metric interface {
 	// Time return the timestamp for the metric
 	Time() time.Time
 
+	// Type returns the metric type. Can be either telegraf.Gauge or telegraf.Counter
+	Type() ValueType
+
 	// UnixNano returns the unix nano time of the metric
 	UnixNano() int64
 
@@ -35,12 +49,11 @@ type Metric interface {
 // metric is a wrapper of the influxdb client.Point struct
 type metric struct {
 	pt *client.Point
+
+	mType ValueType
 }
 
-// NewMetric returns a metric with the given timestamp. If a timestamp is not
-// given, then data is sent to the database without a timestamp, in which case
-// the server will assign local time upon reception. NOTE: it is recommended to
-// send data with a timestamp.
+// NewMetric returns an untyped metric.
 func NewMetric(
 	name string,
 	tags map[string]string,
@@ -52,7 +65,46 @@ func NewMetric(
 		return nil, err
 	}
 	return &metric{
-		pt: pt,
+		pt:    pt,
+		mType: Untyped,
+	}, nil
+}
+
+// NewGaugeMetric returns a gauge metric.
+// Gauge metrics should be used when the metric is can arbitrarily go up and
+// down. ie, temperature, memory usage, cpu usage, etc.
+func NewGaugeMetric(
+	name string,
+	tags map[string]string,
+	fields map[string]interface{},
+	t time.Time,
+) (Metric, error) {
+	pt, err := client.NewPoint(name, tags, fields, t)
+	if err != nil {
+		return nil, err
+	}
+	return &metric{
+		pt:    pt,
+		mType: Gauge,
+	}, nil
+}
+
+// NewCounterMetric returns a Counter metric.
+// Counter metrics should be used when the metric being created is an
+// always-increasing counter. ie, net bytes received, requests served, errors, etc.
+func NewCounterMetric(
+	name string,
+	tags map[string]string,
+	fields map[string]interface{},
+	t time.Time,
+) (Metric, error) {
+	pt, err := client.NewPoint(name, tags, fields, t)
+	if err != nil {
+		return nil, err
+	}
+	return &metric{
+		pt:    pt,
+		mType: Counter,
 	}, nil
 }
 
@@ -68,6 +120,10 @@ func (m *metric) Time() time.Time {
 	return m.pt.Time()
 }
 
+func (m *metric) Type() ValueType {
+	return m.mType
+}
+
 func (m *metric) UnixNano() int64 {
 	return m.pt.UnixNano()
 }

metric_test.go

@@ -23,6 +23,51 @@ func TestNewMetric(t *testing.T) {
 	m, err := NewMetric("cpu", tags, fields, now)
 	assert.NoError(t, err)
 
+	assert.Equal(t, Untyped, m.Type())
+	assert.Equal(t, tags, m.Tags())
+	assert.Equal(t, fields, m.Fields())
+	assert.Equal(t, "cpu", m.Name())
+	assert.Equal(t, now, m.Time())
+	assert.Equal(t, now.UnixNano(), m.UnixNano())
+}
+
+func TestNewGaugeMetric(t *testing.T) {
+	now := time.Now()
+
+	tags := map[string]string{
+		"host":       "localhost",
+		"datacenter": "us-east-1",
+	}
+	fields := map[string]interface{}{
+		"usage_idle": float64(99),
+		"usage_busy": float64(1),
+	}
+	m, err := NewGaugeMetric("cpu", tags, fields, now)
+	assert.NoError(t, err)
+
+	assert.Equal(t, Gauge, m.Type())
+	assert.Equal(t, tags, m.Tags())
+	assert.Equal(t, fields, m.Fields())
+	assert.Equal(t, "cpu", m.Name())
+	assert.Equal(t, now, m.Time())
+	assert.Equal(t, now.UnixNano(), m.UnixNano())
+}
+
+func TestNewCounterMetric(t *testing.T) {
+	now := time.Now()
+
+	tags := map[string]string{
+		"host":       "localhost",
+		"datacenter": "us-east-1",
+	}
+	fields := map[string]interface{}{
+		"usage_idle": float64(99),
+		"usage_busy": float64(1),
+	}
+	m, err := NewCounterMetric("cpu", tags, fields, now)
+	assert.NoError(t, err)
+
+	assert.Equal(t, Counter, m.Type())
 	assert.Equal(t, tags, m.Tags())
 	assert.Equal(t, fields, m.Fields())
 	assert.Equal(t, "cpu", m.Name())

plugins/inputs/aerospike/aerospike.go

@@ -1,6 +1,8 @@
 package aerospike
 
 import (
+	"errors"
+	"log"
 	"net"
 	"strconv"
 	"strings"
@@ -11,7 +13,7 @@ import (
 	"github.com/influxdata/telegraf/internal/errchan"
 	"github.com/influxdata/telegraf/plugins/inputs"
 
-	as "github.com/sparrc/aerospike-client-go"
+	as "github.com/aerospike/aerospike-client-go"
 )
 
 type Aerospike struct {
@@ -82,7 +84,12 @@ func (a *Aerospike) gatherServer(hostport string, acc telegraf.Accumulator) erro
 			return err
 		}
 		for k, v := range stats {
-			fields[strings.Replace(k, "-", "_", -1)] = parseValue(v)
+			val, err := parseValue(v)
+			if err == nil {
+				fields[strings.Replace(k, "-", "_", -1)] = val
+			} else {
+				log.Printf("I! skipping aerospike field %v with int64 overflow", k)
+			}
 		}
 		acc.AddFields("aerospike_node", fields, tags, time.Now())
 
@@ -110,7 +117,12 @@ func (a *Aerospike) gatherServer(hostport string, acc telegraf.Accumulator) erro
 				if len(parts) < 2 {
 					continue
 				}
-				nFields[strings.Replace(parts[0], "-", "_", -1)] = parseValue(parts[1])
+				val, err := parseValue(parts[1])
+				if err == nil {
+					nFields[strings.Replace(parts[0], "-", "_", -1)] = val
+				} else {
+					log.Printf("I! skipping aerospike field %v with int64 overflow", parts[0])
+				}
 			}
 			acc.AddFields("aerospike_namespace", nFields, nTags, time.Now())
 		}
@@ -118,13 +130,16 @@ func (a *Aerospike) gatherServer(hostport string, acc telegraf.Accumulator) erro
 	return nil
 }
 
-func parseValue(v string) interface{} {
+func parseValue(v string) (interface{}, error) {
 	if parsed, err := strconv.ParseInt(v, 10, 64); err == nil {
-		return parsed
+		return parsed, nil
+	} else if _, err := strconv.ParseUint(v, 10, 64); err == nil {
+		// int64 overflow, yet valid uint64
+		return nil, errors.New("Number is too large")
 	} else if parsed, err := strconv.ParseBool(v); err == nil {
-		return parsed
+		return parsed, nil
 	} else {
-		return v
+		return v, nil
 	}
 }
 

plugins/inputs/aerospike/aerospike_test.go

@@ -10,7 +10,7 @@ import (
 
 func TestAerospikeStatistics(t *testing.T) {
 	if testing.Short() {
-		t.Skip("Skipping integration test in short mode")
+		t.Skip("Skipping aerospike integration tests.")
 	}
 
 	a := &Aerospike{
@@ -29,7 +29,7 @@ func TestAerospikeStatistics(t *testing.T) {
 
 func TestAerospikeStatisticsPartialErr(t *testing.T) {
 	if testing.Short() {
-		t.Skip("Skipping integration test in short mode")
+		t.Skip("Skipping aerospike integration tests.")
 	}
 
 	a := &Aerospike{
@@ -48,3 +48,20 @@ func TestAerospikeStatisticsPartialErr(t *testing.T) {
 	assert.True(t, acc.HasMeasurement("aerospike_namespace"))
 	assert.True(t, acc.HasIntField("aerospike_node", "batch_error"))
 }
+
+func TestAerospikeParseValue(t *testing.T) {
+	// uint64 with value bigger than int64 max
+	val, err := parseValue("18446744041841121751")
+	assert.Nil(t, val)
+	assert.Error(t, err)
+
+	// int values
+	val, err = parseValue("42")
+	assert.NoError(t, err)
+	assert.Equal(t, val, int64(42), "must be parsed as int")
+
+	// string values
+	val, err = parseValue("BB977942A2CA502")
+	assert.NoError(t, err)
+	assert.Equal(t, val, `BB977942A2CA502`, "must be left as string")
+}

plugins/inputs/all/all.go

@@ -23,10 +23,12 @@ import (
 	_ "github.com/influxdata/telegraf/plugins/inputs/graylog"
 	_ "github.com/influxdata/telegraf/plugins/inputs/haproxy"
 	_ "github.com/influxdata/telegraf/plugins/inputs/hddtemp"
+	_ "github.com/influxdata/telegraf/plugins/inputs/http_listener"
 	_ "github.com/influxdata/telegraf/plugins/inputs/http_response"
 	_ "github.com/influxdata/telegraf/plugins/inputs/httpjson"
 	_ "github.com/influxdata/telegraf/plugins/inputs/influxdb"
 	_ "github.com/influxdata/telegraf/plugins/inputs/ipmi_sensor"
+	_ "github.com/influxdata/telegraf/plugins/inputs/iptables"
 	_ "github.com/influxdata/telegraf/plugins/inputs/jolokia"
 	_ "github.com/influxdata/telegraf/plugins/inputs/kafka_consumer"
 	_ "github.com/influxdata/telegraf/plugins/inputs/leofs"

plugins/inputs/cassandra/cassandra.go

@@ -274,7 +274,7 @@ func (c *Cassandra) Gather(acc telegraf.Accumulator) error {
 				m = newCassandraMetric(serverTokens["host"], metric, acc)
 			} else {
 				// unsupported metric type
-				log.Printf("Unsupported Cassandra metric [%s], skipping",
+				log.Printf("I! Unsupported Cassandra metric [%s], skipping",
 					metric)
 				continue
 			}

plugins/inputs/ceph/README.md

@@ -2,7 +2,9 @@
 
 Collects performance metrics from the MON and OSD nodes in a Ceph storage cluster.
 
-The plugin works by scanning the configured SocketDir for OSD and MON socket files.  When it finds
+*Admin Socket Stats*
+
+This gatherer works by scanning the configured SocketDir for OSD and MON socket files.  When it finds
 a MON socket, it runs **ceph --admin-daemon $file perfcounters_dump**. For OSDs it runs **ceph --admin-daemon $file perf dump**
 
 The resulting JSON is parsed and grouped into collections, based on top-level key.  Top-level keys are
@@ -27,11 +29,26 @@ Would be parsed into the following metrics, all of which would be tagged with co
  - refresh_latency.sum: 5378.794002000
 
 
+*Cluster Stats*
+
+This gatherer works by invoking ceph commands against the cluster thus only requires the ceph client, valid
+ceph configuration and an access key to function (the ceph_config and ceph_user configuration variables work
+in conjunction to specify these prerequisites). It may be run on any server you wish which has access to
+the cluster.  The currently supported commands are:
+
+* ceph status
+* ceph df
+* ceph osd pool stats
+
 ### Configuration:
 
 ```
 # Collects performance metrics from the MON and OSD nodes in a Ceph storage cluster.
 [[inputs.ceph]]
+  ## This is the recommended interval to poll.  Too frequent and you will lose
+  ## data points due to timeouts during rebalancing and recovery
+  interval = '1m'
+
   ## All configuration values are optional, defaults are shown below
 
   ## location of ceph binary
@@ -46,15 +63,86 @@ Would be parsed into the following metrics, all of which would be tagged with co
 
   ## suffix used to identify socket files
   socket_suffix = "asok"
+
+  ## Ceph user to authenticate as, ceph will search for the corresponding keyring
+  ## e.g. client.admin.keyring in /etc/ceph, or the explicit path defined in the
+  ## client section of ceph.conf for example:
+  ##
+  ##     [client.telegraf]
+  ##         keyring = /etc/ceph/client.telegraf.keyring
+  ##
+  ## Consult the ceph documentation for more detail on keyring generation.
+  ceph_user = "client.admin"
+
+  ## Ceph configuration to use to locate the cluster
+  ceph_config = "/etc/ceph/ceph.conf"
+
+  ## Whether to gather statistics via the admin socket
+  gather_admin_socket_stats = true
+
+  ## Whether to gather statistics via ceph commands, requires ceph_user and ceph_config
+  ## to be specified
+  gather_cluster_stats = true
 ```
 
 ### Measurements & Fields:
 
+*Admin Socket Stats*
+
 All fields are collected under the **ceph** measurement and stored as float64s. For a full list of fields, see the sample perf dumps in ceph_test.go.
 
+*Cluster Stats*
+
+* ceph\_osdmap
+  * epoch (float)
+  * full (boolean)
+  * nearfull (boolean)
+  * num\_in\_osds (float)
+  * num\_osds (float)
+  * num\_remremapped\_pgs (float)
+  * num\_up\_osds (float)
+
+* ceph\_pgmap
+  * bytes\_avail (float)
+  * bytes\_total (float)
+  * bytes\_used (float)
+  * data\_bytes (float)
+  * num\_pgs (float)
+  * op\_per\_sec (float)
+  * read\_bytes\_sec (float)
+  * version (float)
+  * write\_bytes\_sec (float)
+  * recovering\_bytes\_per\_sec (float)
+  * recovering\_keys\_per\_sec (float)
+  * recovering\_objects\_per\_sec (float)
+
+* ceph\_pgmap\_state
+  * state name e.g. active+clean (float)
+
+* ceph\_usage
+  * bytes\_used (float)
+  * kb\_used (float)
+  * max\_avail (float)
+  * objects (float)
+
+* ceph\_pool\_usage
+  * bytes\_used (float)
+  * kb\_used (float)
+  * max\_avail (float)
+  * objects (float)
+
+* ceph\_pool\_stats
+  * op\_per\_sec (float)
+  * read\_bytes\_sec (float)
+  * write\_bytes\_sec (float)
+  * recovering\_object\_per\_sec (float)
+  * recovering\_bytes\_per\_sec (float)
+  * recovering\_keys\_per\_sec (float)
 
 ### Tags:
 
+*Admin Socket Stats*
+
 All measurements will have the following tags:
 
 - type: either 'osd' or 'mon' to indicate which type of node was queried
@@ -96,9 +184,21 @@ All measurements will have the following tags:
     - throttle-osd_client_bytes
     - throttle-osd_client_messages
 
+*Cluster Stats*
+
+* ceph\_pg\_state has the following tags:
+  * state (state for which the value applies e.g. active+clean, active+remapped+backfill)
+* ceph\_pool\_usage has the following tags:
+  * id
+  * name
+* ceph\_pool\_stats has the following tags:
+  * id
+  * name
 
 ### Example Output:
 
+*Admin Socket Stats*
+
 <pre>
 telegraf -test -config /etc/telegraf/telegraf.conf -config-directory /etc/telegraf/telegraf.d  -input-filter ceph
 * Plugin: ceph, Collection 1
@@ -107,3 +207,16 @@ telegraf -test -config /etc/telegraf/telegraf.conf -config-directory /etc/telegr
 > ceph,collection=throttle-mon_daemon_bytes,id=node-2,type=mon get=4058121,get_or_fail_fail=0,get_or_fail_success=0,get_sum=6027348117,max=419430400,put=4058121,put_sum=6027348117,take=0,take_sum=0,val=0,wait.avgcount=0,wait.sum=0 1462821234814815661
 > ceph,collection=throttle-msgr_dispatch_throttler-mon,id=node-2,type=mon get=54276277,get_or_fail_fail=0,get_or_fail_success=0,get_sum=370232877040,max=104857600,put=54276277,put_sum=370232877040,take=0,take_sum=0,val=0,wait.avgcount=0,wait.sum=0 1462821234814872064
 </pre>
+
+*Cluster Stats*
+
+<pre>
+> ceph_osdmap,host=ceph-mon-0 epoch=170772,full=false,nearfull=false,num_in_osds=340,num_osds=340,num_remapped_pgs=0,num_up_osds=340 1468841037000000000
+> ceph_pgmap,host=ceph-mon-0 bytes_avail=634895531270144,bytes_total=812117151809536,bytes_used=177221620539392,data_bytes=56979991615058,num_pgs=22952,op_per_sec=15869,read_bytes_sec=43956026,version=39387592,write_bytes_sec=165344818 1468841037000000000
+> ceph_pgmap_state,host=ceph-mon-0 active+clean=22952 1468928660000000000
+> ceph_usage,host=ceph-mon-0 total_avail_bytes=634895514791936,total_bytes=812117151809536,total_used_bytes=177221637017600 1468841037000000000
+> ceph_pool_usage,host=ceph-mon-0,id=150,name=cinder.volumes bytes_used=12648553794802,kb_used=12352103316,max_avail=154342562489244,objects=3026295 1468841037000000000
+> ceph_pool_usage,host=ceph-mon-0,id=182,name=cinder.volumes.flash bytes_used=8541308223964,kb_used=8341121313,max_avail=39388593563936,objects=2075066 1468841037000000000
+> ceph_pool_stats,host=ceph-mon-0,id=150,name=cinder.volumes op_per_sec=1706,read_bytes_sec=28671674,write_bytes_sec=29994541 1468841037000000000
+> ceph_pool_stats,host=ceph-mon-0,id=182,name=cinder.volumes.flash op_per_sec=9748,read_bytes_sec=9605524,write_bytes_sec=45593310 1468841037000000000
+</pre>

plugins/inputs/ceph/ceph.go

@@ -23,33 +23,15 @@ const (
 )
 
 type Ceph struct {
-	CephBinary   string
-	OsdPrefix    string
-	MonPrefix    string
-	SocketDir    string
-	SocketSuffix string
-}
-
-func (c *Ceph) setDefaults() {
-	if c.CephBinary == "" {
-		c.CephBinary = "/usr/bin/ceph"
-	}
-
-	if c.OsdPrefix == "" {
-		c.OsdPrefix = osdPrefix
-	}
-
-	if c.MonPrefix == "" {
-		c.MonPrefix = monPrefix
-	}
-
-	if c.SocketDir == "" {
-		c.SocketDir = "/var/run/ceph"
-	}
-
-	if c.SocketSuffix == "" {
-		c.SocketSuffix = sockSuffix
-	}
+	CephBinary             string
+	OsdPrefix              string
+	MonPrefix              string
+	SocketDir              string
+	SocketSuffix           string
+	CephUser               string
+	CephConfig             string
+	GatherAdminSocketStats bool
+	GatherClusterStats     bool
 }
 
 func (c *Ceph) Description() string {
@@ -57,6 +39,10 @@ func (c *Ceph) Description() string {
 }
 
 var sampleConfig = `
+  ## This is the recommended interval to poll.  Too frequent and you will lose
+  ## data points due to timeouts during rebalancing and recovery
+  interval = '1m'
+
   ## All configuration values are optional, defaults are shown below
 
   ## location of ceph binary
@@ -71,6 +57,18 @@ var sampleConfig = `
 
   ## suffix used to identify socket files
   socket_suffix = "asok"
+
+  ## Ceph user to authenticate as
+  ceph_user = "client.admin"
+
+  ## Ceph configuration to use to locate the cluster
+  ceph_config = "/etc/ceph/ceph.conf"
+
+  ## Whether to gather statistics via the admin socket
+  gather_admin_socket_stats = true
+
+  ## Whether to gather statistics via ceph commands
+  gather_cluster_stats = true
 `
 
 func (c *Ceph) SampleConfig() string {
@@ -78,7 +76,22 @@ func (c *Ceph) SampleConfig() string {
 }
 
 func (c *Ceph) Gather(acc telegraf.Accumulator) error {
-	c.setDefaults()
+	if c.GatherAdminSocketStats {
+		if err := c.gatherAdminSocketStats(acc); err != nil {
+			return err
+		}
+	}
+
+	if c.GatherClusterStats {
+		if err := c.gatherClusterStats(acc); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+func (c *Ceph) gatherAdminSocketStats(acc telegraf.Accumulator) error {
 	sockets, err := findSockets(c)
 	if err != nil {
 		return fmt.Errorf("failed to find sockets at path '%s': %v", c.SocketDir, err)
@@ -87,12 +100,12 @@ func (c *Ceph) Gather(acc telegraf.Accumulator) error {
 	for _, s := range sockets {
 		dump, err := perfDump(c.CephBinary, s)
 		if err != nil {
-			log.Printf("error reading from socket '%s': %v", s.socket, err)
+			log.Printf("E! error reading from socket '%s': %v", s.socket, err)
 			continue
 		}
 		data, err := parseDump(dump)
 		if err != nil {
-			log.Printf("error parsing dump from socket '%s': %v", s.socket, err)
+			log.Printf("E! error parsing dump from socket '%s': %v", s.socket, err)
 			continue
 		}
 		for tag, metrics := range *data {
@@ -104,8 +117,46 @@ func (c *Ceph) Gather(acc telegraf.Accumulator) error {
 	return nil
 }
 
+func (c *Ceph) gatherClusterStats(acc telegraf.Accumulator) error {
+	jobs := []struct {
+		command string
+		parser  func(telegraf.Accumulator, string) error
+	}{
+		{"status", decodeStatus},
+		{"df", decodeDf},
+		{"osd pool stats", decodeOsdPoolStats},
+	}
+
+	// For each job, execute against the cluster, parse and accumulate the data points
+	for _, job := range jobs {
+		output, err := c.exec(job.command)
+		if err != nil {
+			return fmt.Errorf("error executing command: %v", err)
+		}
+		err = job.parser(acc, output)
+		if err != nil {
+			return fmt.Errorf("error parsing output: %v", err)
+		}
+	}
+
+	return nil
+}
+
 func init() {
-	inputs.Add(measurement, func() telegraf.Input { return &Ceph{} })
+	c := Ceph{
+		CephBinary:             "/usr/bin/ceph",
+		OsdPrefix:              osdPrefix,
+		MonPrefix:              monPrefix,
+		SocketDir:              "/var/run/ceph",
+		SocketSuffix:           sockSuffix,
+		CephUser:               "client.admin",
+		CephConfig:             "/etc/ceph/ceph.conf",
+		GatherAdminSocketStats: true,
+		GatherClusterStats:     false,
+	}
+
+	inputs.Add(measurement, func() telegraf.Input { return &c })
+
 }
 
 var perfDump = func(binary string, socket *socket) (string, error) {
@@ -242,8 +293,197 @@ func flatten(data interface{}) []*metric {
 			}
 		}
 	default:
-		log.Printf("Ignoring unexpected type '%T' for value %v", val, val)
+		log.Printf("I! Ignoring unexpected type '%T' for value %v", val, val)
 	}
 
 	return metrics
 }
+
+func (c *Ceph) exec(command string) (string, error) {
+	cmdArgs := []string{"--conf", c.CephConfig, "--name", c.CephUser, "--format", "json"}
+	cmdArgs = append(cmdArgs, strings.Split(command, " ")...)
+
+	cmd := exec.Command(c.CephBinary, cmdArgs...)
+
+	var out bytes.Buffer
+	cmd.Stdout = &out
+	err := cmd.Run()
+	if err != nil {
+		return "", fmt.Errorf("error running ceph %v: %s", command, err)
+	}
+
+	output := out.String()
+
+	// Ceph doesn't sanitize its output, and may return invalid JSON.  Patch this
+	// up for them, as having some inaccurate data is better than none.
+	output = strings.Replace(output, "-inf", "0", -1)
+	output = strings.Replace(output, "inf", "0", -1)
+
+	return output, nil
+}
+
+func decodeStatus(acc telegraf.Accumulator, input string) error {
+	data := make(map[string]interface{})
+	err := json.Unmarshal([]byte(input), &data)
+	if err != nil {
+		return fmt.Errorf("failed to parse json: '%s': %v", input, err)
+	}
+
+	err = decodeStatusOsdmap(acc, data)
+	if err != nil {
+		return err
+	}
+
+	err = decodeStatusPgmap(acc, data)
+	if err != nil {
+		return err
+	}
+
+	err = decodeStatusPgmapState(acc, data)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func decodeStatusOsdmap(acc telegraf.Accumulator, data map[string]interface{}) error {
+	osdmap, ok := data["osdmap"].(map[string]interface{})
+	if !ok {
+		return fmt.Errorf("WARNING %s - unable to decode osdmap", measurement)
+	}
+	fields, ok := osdmap["osdmap"].(map[string]interface{})
+	if !ok {
+		return fmt.Errorf("WARNING %s - unable to decode osdmap", measurement)
+	}
+	acc.AddFields("ceph_osdmap", fields, map[string]string{})
+	return nil
+}
+
+func decodeStatusPgmap(acc telegraf.Accumulator, data map[string]interface{}) error {
+	pgmap, ok := data["pgmap"].(map[string]interface{})
+	if !ok {
+		return fmt.Errorf("WARNING %s - unable to decode pgmap", measurement)
+	}
+	fields := make(map[string]interface{})
+	for key, value := range pgmap {
+		switch value.(type) {
+		case float64:
+			fields[key] = value
+		}
+	}
+	acc.AddFields("ceph_pgmap", fields, map[string]string{})
+	return nil
+}
+
+func decodeStatusPgmapState(acc telegraf.Accumulator, data map[string]interface{}) error {
+	pgmap, ok := data["pgmap"].(map[string]interface{})
+	if !ok {
+		return fmt.Errorf("WARNING %s - unable to decode pgmap", measurement)
+	}
+	fields := make(map[string]interface{})
+	for key, value := range pgmap {
+		switch value.(type) {
+		case []interface{}:
+			if key != "pgs_by_state" {
+				continue
+			}
+			for _, state := range value.([]interface{}) {
+				state_map, ok := state.(map[string]interface{})
+				if !ok {
+					return fmt.Errorf("WARNING %s - unable to decode pg state", measurement)
+				}
+				state_name, ok := state_map["state_name"].(string)
+				if !ok {
+					return fmt.Errorf("WARNING %s - unable to decode pg state name", measurement)
+				}
+				state_count, ok := state_map["count"].(float64)
+				if !ok {
+					return fmt.Errorf("WARNING %s - unable to decode pg state count", measurement)
+				}
+				fields[state_name] = state_count
+			}
+		}
+	}
+	acc.AddFields("ceph_pgmap_state", fields, map[string]string{})
+	return nil
+}
+
+func decodeDf(acc telegraf.Accumulator, input string) error {
+	data := make(map[string]interface{})
+	err := json.Unmarshal([]byte(input), &data)
+	if err != nil {
+		return fmt.Errorf("failed to parse json: '%s': %v", input, err)
+	}
+
+	// ceph.usage: records global utilization and number of objects
+	stats_fields, ok := data["stats"].(map[string]interface{})
+	if !ok {
+		return fmt.Errorf("WARNING %s - unable to decode df stats", measurement)
+	}
+	acc.AddFields("ceph_usage", stats_fields, map[string]string{})
+
+	// ceph.pool.usage: records per pool utilization and number of objects
+	pools, ok := data["pools"].([]interface{})
+	if !ok {
+		return fmt.Errorf("WARNING %s - unable to decode df pools", measurement)
+	}
+
+	for _, pool := range pools {
+		pool_map, ok := pool.(map[string]interface{})
+		if !ok {
+			return fmt.Errorf("WARNING %s - unable to decode df pool", measurement)
+		}
+		pool_name, ok := pool_map["name"].(string)
+		if !ok {
+			return fmt.Errorf("WARNING %s - unable to decode df pool name", measurement)
+		}
+		fields, ok := pool_map["stats"].(map[string]interface{})
+		if !ok {
+			return fmt.Errorf("WARNING %s - unable to decode df pool stats", measurement)
+		}
+		tags := map[string]string{
+			"name": pool_name,
+		}
+		acc.AddFields("ceph_pool_usage", fields, tags)
+	}
+
+	return nil
+}
+
+func decodeOsdPoolStats(acc telegraf.Accumulator, input string) error {
+	data := make([]map[string]interface{}, 0)
+	err := json.Unmarshal([]byte(input), &data)
+	if err != nil {
+		return fmt.Errorf("failed to parse json: '%s': %v", input, err)
+	}
+
+	// ceph.pool.stats: records pre pool IO and recovery throughput
+	for _, pool := range data {
+		pool_name, ok := pool["pool_name"].(string)
+		if !ok {
+			return fmt.Errorf("WARNING %s - unable to decode osd pool stats name", measurement)
+		}
+		// Note: the 'recovery' object looks broken (in hammer), so it's omitted
+		objects := []string{
+			"client_io_rate",
+			"recovery_rate",
+		}
+		fields := make(map[string]interface{})
+		for _, object := range objects {
+			perfdata, ok := pool[object].(map[string]interface{})
+			if !ok {
+				return fmt.Errorf("WARNING %s - unable to decode osd pool stats", measurement)
+			}
+			for key, value := range perfdata {
+				fields[key] = value
+			}
+		}
+		tags := map[string]string{
+			"name": pool_name,
+		}
+		acc.AddFields("ceph_pool_stats", fields, tags)
+	}
+
+	return nil
+}

plugins/inputs/ceph/ceph_test.go

@@ -65,12 +65,17 @@ func TestFindSockets(t *testing.T) {
 		assert.NoError(t, err)
 	}()
 	c := &Ceph{
-		CephBinary: "foo",
-		SocketDir:  tmpdir,
+		CephBinary:             "foo",
+		OsdPrefix:              "ceph-osd",
+		MonPrefix:              "ceph-mon",
+		SocketDir:              tmpdir,
+		SocketSuffix:           "asok",
+		CephUser:               "client.admin",
+		CephConfig:             "/etc/ceph/ceph.conf",
+		GatherAdminSocketStats: true,
+		GatherClusterStats:     false,
 	}
 
-	c.setDefaults()
-
 	for _, st := range sockTestParams {
 		createTestFiles(tmpdir, st)
 

plugins/inputs/cloudwatch/README.md

@@ -34,6 +34,11 @@ API endpoint. In the following order the plugin will attempt to authenticate.
   ## Metric Statistic Namespace (required)
   namespace = 'AWS/ELB'
 
+  ## Maximum requests per second. Note that the global default AWS rate limit is
+  ## 10 reqs/sec, so if you define multiple namespaces, these should add up to a
+  ## maximum of 10. Optional - default value is 10.
+  ratelimit = 10
+
   ## Metrics to Pull (optional)
   ## Defaults to all Metrics in Namespace if nothing is provided
   ## Refreshes Namespace available metrics every 1h

plugins/inputs/cloudwatch/cloudwatch.go

@@ -33,6 +33,7 @@ type (
 		Namespace   string            `toml:"namespace"`
 		Metrics     []*Metric         `toml:"metrics"`
 		CacheTTL    internal.Duration `toml:"cache_ttl"`
+		RateLimit   int               `toml:"ratelimit"`
 		client      cloudwatchClient
 		metricCache *MetricCache
 	}
@@ -96,6 +97,11 @@ func (c *CloudWatch) SampleConfig() string {
   ## Metric Statistic Namespace (required)
   namespace = 'AWS/ELB'
 
+  ## Maximum requests per second. Note that the global default AWS rate limit is
+  ## 10 reqs/sec, so if you define multiple namespaces, these should add up to a
+  ## maximum of 10. Optional - default value is 10.
+  ratelimit = 10
+
   ## Metrics to Pull (optional)
   ## Defaults to all Metrics in Namespace if nothing is provided
   ## Refreshes Namespace available metrics every 1h
@@ -175,7 +181,7 @@ func (c *CloudWatch) Gather(acc telegraf.Accumulator) error {
 	// limit concurrency or we can easily exhaust user connection limit
 	// see cloudwatch API request limits:
 	// http://docs.aws.amazon.com/AmazonCloudWatch/latest/DeveloperGuide/cloudwatch_limits.html
-	lmtr := limiter.NewRateLimiter(10, time.Second)
+	lmtr := limiter.NewRateLimiter(c.RateLimit, time.Second)
 	defer lmtr.Stop()
 	var wg sync.WaitGroup
 	wg.Add(len(metrics))
@@ -195,7 +201,8 @@ func init() {
 	inputs.Add("cloudwatch", func() telegraf.Input {
 		ttl, _ := time.ParseDuration("1hr")
 		return &CloudWatch{
-			CacheTTL: internal.Duration{Duration: ttl},
+			CacheTTL:  internal.Duration{Duration: ttl},
+			RateLimit: 10,
 		}
 	})
 }

plugins/inputs/cloudwatch/cloudwatch_test.go

@@ -58,6 +58,7 @@ func TestGather(t *testing.T) {
 		Namespace: "AWS/ELB",
 		Delay:     internalDuration,
 		Period:    internalDuration,
+		RateLimit: 10,
 	}
 
 	var acc testutil.Accumulator

plugins/inputs/conntrack/conntrack.go

@@ -93,13 +93,14 @@ func (c *Conntrack) Gather(acc telegraf.Accumulator) error {
 
 			contents, err := ioutil.ReadFile(fName)
 			if err != nil {
-				log.Printf("failed to read file '%s': %v", fName, err)
+				log.Printf("E! failed to read file '%s': %v", fName, err)
+				continue
 			}
 
 			v := strings.TrimSpace(string(contents))
 			fields[metricKey], err = strconv.ParseFloat(v, 64)
 			if err != nil {
-				log.Printf("failed to parse metric, expected number but "+
+				log.Printf("E! failed to parse metric, expected number but "+
 					" found '%s': %v", v, err)
 			}
 		}

plugins/inputs/docker/README.md

@@ -103,6 +103,9 @@ based on the availability of per-cpu stats on your system.
     - n_used_file_descriptors
     - n_cpus
     - n_containers
+    - n_containers_running
+    - n_containers_stopped
+    - n_containers_paused
     - n_images
     - n_goroutines
     - n_listener_events
@@ -153,6 +156,9 @@ based on the availability of per-cpu stats on your system.
 > docker n_cpus=8i 1456926671065383978
 > docker n_used_file_descriptors=15i 1456926671065383978
 > docker n_containers=7i 1456926671065383978
+> docker n_containers_running=7i 1456926671065383978
+> docker n_containers_stopped=3i 1456926671065383978
+> docker n_containers_paused=0i 1456926671065383978
 > docker n_images=152i 1456926671065383978
 > docker n_goroutines=36i 1456926671065383978
 > docker n_listener_events=0i 1456926671065383978

plugins/inputs/docker/docker.go

@@ -28,7 +28,8 @@ type Docker struct {
 	PerDevice      bool `toml:"perdevice"`
 	Total          bool `toml:"total"`
 
-	client DockerClient
+	client      DockerClient
+	engine_host string
 }
 
 // DockerClient interface, useful for testing
@@ -125,7 +126,7 @@ func (d *Docker) Gather(acc telegraf.Accumulator) error {
 			defer wg.Done()
 			err := d.gatherContainer(c, acc)
 			if err != nil {
-				log.Printf("Error gathering container %s stats: %s\n",
+				log.Printf("E! Error gathering container %s stats: %s\n",
 					c.Names, err.Error())
 			}
 		}(container)
@@ -147,11 +148,15 @@ func (d *Docker) gatherInfo(acc telegraf.Accumulator) error {
 	if err != nil {
 		return err
 	}
+	d.engine_host = info.Name
 
 	fields := map[string]interface{}{
 		"n_cpus":                  info.NCPU,
 		"n_used_file_descriptors": info.NFd,
 		"n_containers":            info.Containers,
+		"n_containers_running":    info.ContainersRunning,
+		"n_containers_stopped":    info.ContainersStopped,
+		"n_containers_paused":     info.ContainersPaused,
 		"n_images":                info.Images,
 		"n_goroutines":            info.NGoroutines,
 		"n_listener_events":       info.NEventsListener,
@@ -159,11 +164,11 @@ func (d *Docker) gatherInfo(acc telegraf.Accumulator) error {
 	// Add metrics
 	acc.AddFields("docker",
 		fields,
-		nil,
+		map[string]string{"engine_host": d.engine_host},
 		now)
 	acc.AddFields("docker",
 		map[string]interface{}{"memory_total": info.MemTotal},
-		map[string]string{"unit": "bytes"},
+		map[string]string{"unit": "bytes", "engine_host": d.engine_host},
 		now)
 	// Get storage metrics
 	for _, rawData := range info.DriverStatus {
@@ -177,7 +182,7 @@ func (d *Docker) gatherInfo(acc telegraf.Accumulator) error {
 			// pool blocksize
 			acc.AddFields("docker",
 				map[string]interface{}{"pool_blocksize": value},
-				map[string]string{"unit": "bytes"},
+				map[string]string{"unit": "bytes", "engine_host": d.engine_host},
 				now)
 		} else if strings.HasPrefix(name, "data_space_") {
 			// data space
@@ -192,13 +197,13 @@ func (d *Docker) gatherInfo(acc telegraf.Accumulator) error {
 	if len(dataFields) > 0 {
 		acc.AddFields("docker_data",
 			dataFields,
-			map[string]string{"unit": "bytes"},
+			map[string]string{"unit": "bytes", "engine_host": d.engine_host},
 			now)
 	}
 	if len(metadataFields) > 0 {
 		acc.AddFields("docker_metadata",
 			metadataFields,
-			map[string]string{"unit": "bytes"},
+			map[string]string{"unit": "bytes", "engine_host": d.engine_host},
 			now)
 	}
 	return nil
@@ -225,6 +230,7 @@ func (d *Docker) gatherContainer(
 		imageVersion = imageParts[1]
 	}
 	tags := map[string]string{
+		"engine_host":       d.engine_host,
 		"container_name":    cname,
 		"container_image":   imageName,
 		"container_version": imageVersion,

plugins/inputs/docker/docker_test.go

@@ -256,6 +256,9 @@ type FakeDockerClient struct {
 func (d FakeDockerClient) Info(ctx context.Context) (types.Info, error) {
 	env := types.Info{
 		Containers:         108,
+		ContainersRunning:  98,
+		ContainersStopped:  6,
+		ContainersPaused:   3,
 		OomKillDisable:     false,
 		SystemTime:         "2016-02-24T00:55:09.15073105-05:00",
 		NEventsListener:    0,
@@ -397,10 +400,13 @@ func TestDockerGatherInfo(t *testing.T) {
 			"n_cpus":                  int(4),
 			"n_used_file_descriptors": int(19),
 			"n_containers":            int(108),
+			"n_containers_running":    int(98),
+			"n_containers_stopped":    int(6),
+			"n_containers_paused":     int(3),
 			"n_images":                int(199),
 			"n_goroutines":            int(39),
 		},
-		map[string]string{},
+		map[string]string{"engine_host": "absol"},
 	)
 
 	acc.AssertContainsTaggedFields(t,
@@ -411,7 +417,8 @@ func TestDockerGatherInfo(t *testing.T) {
 			"available": int64(36530000000),
 		},
 		map[string]string{
-			"unit": "bytes",
+			"unit":        "bytes",
+			"engine_host": "absol",
 		},
 	)
 	acc.AssertContainsTaggedFields(t,
@@ -425,6 +432,7 @@ func TestDockerGatherInfo(t *testing.T) {
 			"container_image":   "quay.io/coreos/etcd",
 			"cpu":               "cpu3",
 			"container_version": "v2.2.2",
+			"engine_host":       "absol",
 		},
 	)
 	acc.AssertContainsTaggedFields(t,
@@ -467,6 +475,7 @@ func TestDockerGatherInfo(t *testing.T) {
 			"container_id":              "b7dfbb9478a6ae55e237d4d74f8bbb753f0817192b5081334dc78476296e2173",
 		},
 		map[string]string{
+			"engine_host":       "absol",
 			"container_name":    "etcd2",
 			"container_image":   "quay.io/coreos/etcd",
 			"container_version": "v2.2.2",

plugins/inputs/elasticsearch/README.md

@@ -8,9 +8,18 @@ and optionally [cluster](https://www.elastic.co/guide/en/elasticsearch/reference
 
 ```
 [[inputs.elasticsearch]]
+  ## specify a list of one or more Elasticsearch servers
   servers = ["http://localhost:9200"]
+
+  ## Timeout for HTTP requests to the elastic search server(s)
+  http_timeout = "5s"
+
+  ## set local to false when you want to read the indices stats from all nodes
+  ## within the cluster
   local = true
-  cluster_health = true
+
+  ## set cluster_health to true when you want to also obtain cluster level stats
+  cluster_health = false
 
   ## Optional SSL Config
   # ssl_ca = "/etc/telegraf/ca.pem"

plugins/inputs/elasticsearch/elasticsearch.go

@@ -62,6 +62,9 @@ const sampleConfig = `
   ## specify a list of one or more Elasticsearch servers
   servers = ["http://localhost:9200"]
 
+  ## Timeout for HTTP requests to the elastic search server(s)
+  http_timeout = "5s"
+
   ## set local to false when you want to read the indices stats from all nodes
   ## within the cluster
   local = true
@@ -82,6 +85,7 @@ const sampleConfig = `
 type Elasticsearch struct {
 	Local              bool
 	Servers            []string
+	HttpTimeout        internal.Duration
 	ClusterHealth      bool
 	SSLCA              string `toml:"ssl_ca"`   // Path to CA file
 	SSLCert            string `toml:"ssl_cert"` // Path to host cert file
@@ -92,7 +96,9 @@ type Elasticsearch struct {
 
 // NewElasticsearch return a new instance of Elasticsearch
 func NewElasticsearch() *Elasticsearch {
-	return &Elasticsearch{}
+	return &Elasticsearch{
+		HttpTimeout: internal.Duration{Duration: time.Second * 5},
+	}
 }
 
 // SampleConfig returns sample configuration for this plugin.
@@ -150,12 +156,12 @@ func (e *Elasticsearch) createHttpClient() (*http.Client, error) {
 		return nil, err
 	}
 	tr := &http.Transport{
-		ResponseHeaderTimeout: time.Duration(3 * time.Second),
+		ResponseHeaderTimeout: e.HttpTimeout.Duration,
 		TLSClientConfig:       tlsCfg,
 	}
 	client := &http.Client{
 		Transport: tr,
-		Timeout:   time.Duration(4 * time.Second),
+		Timeout:   e.HttpTimeout.Duration,
 	}
 
 	return client, nil

plugins/inputs/exec/exec.go

@@ -5,6 +5,7 @@ import (
 	"fmt"
 	"os/exec"
 	"path/filepath"
+	"runtime"
 	"strings"
 	"sync"
 	"syscall"
@@ -114,9 +115,36 @@ func (c CommandRunner) Run(
 		}
 	}
 
+	out = removeCarriageReturns(out)
 	return out.Bytes(), nil
 }
 
+// removeCarriageReturns removes all carriage returns from the input if the
+// OS is Windows. It does not return any errors.
+func removeCarriageReturns(b bytes.Buffer) bytes.Buffer {
+	if runtime.GOOS == "windows" {
+		var buf bytes.Buffer
+		for {
+			byt, er := b.ReadBytes(0x0D)
+			end := len(byt)
+			if nil == er {
+				end -= 1
+			}
+			if nil != byt {
+				buf.Write(byt[:end])
+			} else {
+				break
+			}
+			if nil != er {
+				break
+			}
+		}
+		b = buf
+	}
+	return b
+
+}
+
 func (e *Exec) ProcessCommand(command string, acc telegraf.Accumulator, wg *sync.WaitGroup) {
 	defer wg.Done()
 

plugins/inputs/exec/exec_test.go

@@ -1,7 +1,9 @@
 package exec
 
 import (
+	"bytes"
 	"fmt"
+	"runtime"
 	"testing"
 
 	"github.com/influxdata/telegraf"
@@ -46,6 +48,29 @@ cpu,cpu=cpu5,host=foo,datacenter=us-east usage_idle=99,usage_busy=1
 cpu,cpu=cpu6,host=foo,datacenter=us-east usage_idle=99,usage_busy=1
 `
 
+type CarriageReturnTest struct {
+	input  []byte
+	output []byte
+}
+
+var crTests = []CarriageReturnTest{
+	{[]byte{0x4c, 0x69, 0x6e, 0x65, 0x20, 0x31, 0x0d, 0x0a, 0x4c, 0x69,
+		0x6e, 0x65, 0x20, 0x32, 0x0d, 0x0a, 0x4c, 0x69, 0x6e, 0x65,
+		0x20, 0x33},
+		[]byte{0x4c, 0x69, 0x6e, 0x65, 0x20, 0x31, 0x0a, 0x4c, 0x69, 0x6e,
+			0x65, 0x20, 0x32, 0x0a, 0x4c, 0x69, 0x6e, 0x65, 0x20, 0x33}},
+	{[]byte{0x4c, 0x69, 0x6e, 0x65, 0x20, 0x31, 0x0a, 0x4c, 0x69, 0x6e,
+		0x65, 0x20, 0x32, 0x0a, 0x4c, 0x69, 0x6e, 0x65, 0x20, 0x33},
+		[]byte{0x4c, 0x69, 0x6e, 0x65, 0x20, 0x31, 0x0a, 0x4c, 0x69, 0x6e,
+			0x65, 0x20, 0x32, 0x0a, 0x4c, 0x69, 0x6e, 0x65, 0x20, 0x33}},
+	{[]byte{0x54, 0x68, 0x69, 0x73, 0x20, 0x69, 0x73, 0x20, 0x61, 0x6c,
+		0x6c, 0x20, 0x6f, 0x6e, 0x65, 0x20, 0x62, 0x69, 0x67, 0x20,
+		0x6c, 0x69, 0x6e, 0x65},
+		[]byte{0x54, 0x68, 0x69, 0x73, 0x20, 0x69, 0x73, 0x20, 0x61, 0x6c,
+			0x6c, 0x20, 0x6f, 0x6e, 0x65, 0x20, 0x62, 0x69, 0x67, 0x20,
+			0x6c, 0x69, 0x6e, 0x65}},
+}
+
 type runnerMock struct {
 	out []byte
 	err error
@@ -217,3 +242,21 @@ func TestExecCommandWithoutGlobAndPath(t *testing.T) {
 	}
 	acc.AssertContainsFields(t, "metric", fields)
 }
+
+func TestRemoveCarriageReturns(t *testing.T) {
+	if runtime.GOOS == "windows" {
+		// Test that all carriage returns are removed
+		for _, test := range crTests {
+			b := bytes.NewBuffer(test.input)
+			out := removeCarriageReturns(*b)
+			assert.True(t, bytes.Equal(test.output, out.Bytes()))
+		}
+	} else {
+		// Test that the buffer is returned unaltered
+		for _, test := range crTests {
+			b := bytes.NewBuffer(test.input)
+			out := removeCarriageReturns(*b)
+			assert.True(t, bytes.Equal(test.input, out.Bytes()))
+		}
+	}
+}

plugins/inputs/http_listener/README.md

@@ -0,0 +1,24 @@
+# HTTP listener service input plugin
+
+The HTTP listener is a service input plugin that listens for messages sent via HTTP POST.
+The plugin expects messages in the InfluxDB line-protocol ONLY, other Telegraf input data formats are not supported.
+The intent of the plugin is to allow Telegraf to serve as a proxy/router for the /write endpoint of the InfluxDB HTTP API.
+When chaining Telegraf instances using this plugin, CREATE DATABASE requests receive a 200 OK response with message body `{"results":[]}` but they are not relayed. The output configuration of the Telegraf instance which ultimately submits data to InfluxDB determines the destination database.
+
+See: [Telegraf Input Data Formats](https://github.com/influxdata/telegraf/blob/master/docs/DATA_FORMATS_INPUT.md#influx).
+Example:  curl -i -XPOST 'http://localhost:8186/write' --data-binary 'cpu_load_short,host=server01,region=us-west value=0.64 1434055562000000000'
+
+### Configuration:
+
+This is a sample configuration for the plugin.
+
+```toml
+# # Influx HTTP write listener
+[[inputs.http_listener]]
+  ## Address and port to host HTTP listener on
+  service_address = ":8186"
+
+  ## timeouts
+  read_timeout = "10s"
+  write_timeout = "10s"
+```

plugins/inputs/http_listener/http_listener.go

@@ -0,0 +1,165 @@
+package http_listener
+
+import (
+	"bufio"
+	"bytes"
+	"fmt"
+	"log"
+	"net"
+	"net/http"
+	"sync"
+	"time"
+
+	"github.com/influxdata/telegraf"
+	"github.com/influxdata/telegraf/internal"
+	"github.com/influxdata/telegraf/plugins/inputs"
+	"github.com/influxdata/telegraf/plugins/inputs/http_listener/stoppableListener"
+	"github.com/influxdata/telegraf/plugins/parsers"
+)
+
+type HttpListener struct {
+	ServiceAddress string
+	ReadTimeout    internal.Duration
+	WriteTimeout   internal.Duration
+
+	sync.Mutex
+	wg sync.WaitGroup
+
+	listener *stoppableListener.StoppableListener
+
+	parser parsers.Parser
+	acc    telegraf.Accumulator
+}
+
+const sampleConfig = `
+  ## Address and port to host HTTP listener on
+  service_address = ":8186"
+
+  ## timeouts
+  read_timeout = "10s"
+  write_timeout = "10s"
+`
+
+func (t *HttpListener) SampleConfig() string {
+	return sampleConfig
+}
+
+func (t *HttpListener) Description() string {
+	return "Influx HTTP write listener"
+}
+
+func (t *HttpListener) Gather(_ telegraf.Accumulator) error {
+	return nil
+}
+
+func (t *HttpListener) SetParser(parser parsers.Parser) {
+	t.parser = parser
+}
+
+// Start starts the http listener service.
+func (t *HttpListener) Start(acc telegraf.Accumulator) error {
+	t.Lock()
+	defer t.Unlock()
+
+	t.acc = acc
+
+	var rawListener, err = net.Listen("tcp", t.ServiceAddress)
+	if err != nil {
+		return err
+	}
+	t.listener, err = stoppableListener.New(rawListener)
+	if err != nil {
+		return err
+	}
+
+	go t.httpListen()
+
+	log.Printf("I! Started HTTP listener service on %s\n", t.ServiceAddress)
+
+	return nil
+}
+
+// Stop cleans up all resources
+func (t *HttpListener) Stop() {
+	t.Lock()
+	defer t.Unlock()
+
+	t.listener.Stop()
+	t.listener.Close()
+
+	t.wg.Wait()
+
+	log.Println("I! Stopped HTTP listener service on ", t.ServiceAddress)
+}
+
+// httpListen listens for HTTP requests.
+func (t *HttpListener) httpListen() error {
+	if t.ReadTimeout.Duration < time.Second {
+		t.ReadTimeout.Duration = time.Second * 10
+	}
+	if t.WriteTimeout.Duration < time.Second {
+		t.WriteTimeout.Duration = time.Second * 10
+	}
+
+	var server = http.Server{
+		Handler:      t,
+		ReadTimeout:  t.ReadTimeout.Duration,
+		WriteTimeout: t.WriteTimeout.Duration,
+	}
+
+	return server.Serve(t.listener)
+}
+
+func (t *HttpListener) ServeHTTP(res http.ResponseWriter, req *http.Request) {
+	t.wg.Add(1)
+	defer t.wg.Done()
+
+	switch req.URL.Path {
+	case "/write":
+		var http400msg bytes.Buffer
+		var partial string
+		scanner := bufio.NewScanner(req.Body)
+		scanner.Buffer([]byte(""), 128*1024)
+		for scanner.Scan() {
+			metrics, err := t.parser.Parse(scanner.Bytes())
+			if err == nil {
+				for _, m := range metrics {
+					t.acc.AddFields(m.Name(), m.Fields(), m.Tags(), m.Time())
+				}
+				partial = "partial write: "
+			} else {
+				http400msg.WriteString(err.Error() + " ")
+			}
+		}
+
+		if err := scanner.Err(); err != nil {
+			http.Error(res, "Internal server error: "+err.Error(), http.StatusInternalServerError)
+		} else if http400msg.Len() > 0 {
+			res.Header().Set("Content-Type", "application/json")
+			res.Header().Set("X-Influxdb-Version", "1.0")
+			res.WriteHeader(http.StatusBadRequest)
+			res.Write([]byte(fmt.Sprintf(`{"error":"%s%s"}`, partial, http400msg.String())))
+		} else {
+			res.WriteHeader(http.StatusNoContent)
+		}
+	case "/query":
+		// Deliver a dummy response to the query endpoint, as some InfluxDB
+		// clients test endpoint availability with a query
+		res.Header().Set("Content-Type", "application/json")
+		res.Header().Set("X-Influxdb-Version", "1.0")
+		res.WriteHeader(http.StatusOK)
+		res.Write([]byte("{\"results\":[]}"))
+	case "/ping":
+		// respond to ping requests
+		res.WriteHeader(http.StatusNoContent)
+	default:
+		// Don't know how to respond to calls to other endpoints
+		http.NotFound(res, req)
+	}
+}
+
+func init() {
+	inputs.Add("http_listener", func() telegraf.Input {
+		return &HttpListener{}
+	})
+}

plugins/inputs/http_listener/stoppableListener/LICENSE

@@ -0,0 +1,10 @@
+Copyright (c) 2014, Eric Urban
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

plugins/inputs/http_listener/stoppableListener/listener.go

@@ -0,0 +1,62 @@
+package stoppableListener
+
+import (
+	"errors"
+	"net"
+	"time"
+)
+
+type StoppableListener struct {
+	*net.TCPListener          //Wrapped listener
+	stop             chan int //Channel used only to indicate listener should shutdown
+}
+
+func New(l net.Listener) (*StoppableListener, error) {
+	tcpL, ok := l.(*net.TCPListener)
+
+	if !ok {
+		return nil, errors.New("Cannot wrap listener")
+	}
+
+	retval := &StoppableListener{}
+	retval.TCPListener = tcpL
+	retval.stop = make(chan int)
+
+	return retval, nil
+}
+
+var StoppedError = errors.New("Listener stopped")
+
+func (sl *StoppableListener) Accept() (net.Conn, error) {
+
+	for {
+		//Wait up to one second for a new connection
+		sl.SetDeadline(time.Now().Add(time.Second))
+
+		newConn, err := sl.TCPListener.Accept()
+
+		//Check for the channel being closed
+		select {
+		case <-sl.stop:
+			return nil, StoppedError
+		default:
+			//If the channel is still open, continue as normal
+		}
+
+		if err != nil {
+			netErr, ok := err.(net.Error)
+
+			//If this is a timeout, then continue to wait for
+			//new connections
+			if ok && netErr.Timeout() && netErr.Temporary() {
+				continue
+			}
+		}
+
+		return newConn, err
+	}
+}
+
+func (sl *StoppableListener) Stop() {
+	close(sl.stop)
+}

plugins/inputs/httpjson/README.md

@@ -2,8 +2,7 @@
 
 The httpjson plugin can collect data from remote URLs which respond with JSON. Then it flattens JSON and finds all numeric values, treating them as floats.
 
-For example, if you have a service called _mycollector_, which has HTTP endpoint for gathering stats at http://my.service.com/_stats, you would configure the HTTP JSON
-plugin like this:
+For example, if you have a service called _mycollector_, which has HTTP endpoint for gathering stats at http://my.service.com/_stats, you would configure the HTTP JSON plugin like this:
 
 ```
 [[inputs.httpjson]]
@@ -15,12 +14,17 @@ plugin like this:
 
   # HTTP method to use (case-sensitive)
   method = "GET"
+
+  # Set response_timeout (default 5 seconds)
+  response_timeout = "5s"
 ```
 
 `name` is used as a prefix for the measurements.
 
 `method` specifies HTTP method to use for requests.
 
+`response_timeout` specifies timeout to wait to get the response
+
 You can also specify which keys from server response should be considered tags:
 
 ```
@@ -94,8 +98,7 @@ httpjson_mycollector_b_e,service='service01',server='http://my.service.com/_stat
 
 # Example 2, Multiple Services:
 
-There is also the option to collect JSON from multiple services, here is an
-example doing that.
+There is also the option to collect JSON from multiple services, here is an example doing that.
 
 ```
 [[inputs.httpjson]]

plugins/inputs/httpjson/httpjson.go

@@ -16,13 +16,15 @@ import (
 	"github.com/influxdata/telegraf/plugins/parsers"
 )
 
+// HttpJson struct
 type HttpJson struct {
-	Name       string
-	Servers    []string
-	Method     string
-	TagKeys    []string
-	Parameters map[string]string
-	Headers    map[string]string
+	Name            string
+	Servers         []string
+	Method          string
+	TagKeys         []string
+	ResponseTimeout internal.Duration
+	Parameters      map[string]string
+	Headers         map[string]string
 
 	// Path to CA file
 	SSLCA string `toml:"ssl_ca"`
@@ -79,6 +81,8 @@ var sampleConfig = `
     "http://localhost:9999/stats/",
     "http://localhost:9998/stats/",
   ]
+  ## Set response_timeout (default 5 seconds)
+  response_timeout = "5s"
 
   ## HTTP method to use: GET or POST (case-sensitive)
   method = "GET"
@@ -126,12 +130,12 @@ func (h *HttpJson) Gather(acc telegraf.Accumulator) error {
 			return err
 		}
 		tr := &http.Transport{
-			ResponseHeaderTimeout: time.Duration(3 * time.Second),
+			ResponseHeaderTimeout: h.ResponseTimeout.Duration,
 			TLSClientConfig:       tlsCfg,
 		}
 		client := &http.Client{
 			Transport: tr,
-			Timeout:   time.Duration(4 * time.Second),
+			Timeout:   h.ResponseTimeout.Duration,
 		}
 		h.client.SetHTTPClient(client)
 	}
@@ -291,6 +295,9 @@ func init() {
 	inputs.Add("httpjson", func() telegraf.Input {
 		return &HttpJson{
 			client: &RealHTTPClient{},
+			ResponseTimeout: internal.Duration{
+				Duration: 5 * time.Second,
+			},
 		}
 	})
 }

plugins/inputs/iptables/README.md

@@ -0,0 +1,74 @@
+# Iptables Plugin
+
+The iptables plugin gathers packets and bytes counters for rules within a set of table and chain from the Linux's iptables firewall.
+
+Rules are identified through associated comment. Rules without comment are ignored.
+
+The iptables command requires CAP_NET_ADMIN and CAP_NET_RAW capabilities. You have several options to grant telegraf to run iptables:
+
+* Run telegraf as root. This is strongly discouraged.
+* Configure systemd to run telegraf with CAP_NET_ADMIN and CAP_NET_RAW. This is the simplest and recommended option.
+* Configure sudo to grant telegraf to run iptables. This is the most restrictive option, but require sudo setup.
+
+### Using systemd capabilities
+
+You may run `systemctl edit telegraf.service` and add the following:
+
+```
+[Service]
+CapabilityBoundingSet=CAP_NET_RAW CAP_NET_ADMIN
+AmbientCapabilities=CAP_NET_RAW CAP_NET_ADMIN
+```
+
+Since telegraf will fork a process to run iptables, `AmbientCapabilities` is required to transmit the capabilities bounding set to the forked process.
+
+### Using sudo
+
+You may edit your sudo configuration with the following:
+
+```sudo
+telegraf ALL=(root) NOPASSWD: /usr/bin/iptables -nvL *
+```
+
+### Configuration:
+
+```toml
+  # use sudo to run iptables
+  use_sudo = false
+  # defines the table to monitor:
+  table = "filter"
+  # defines the chains to monitor:
+  chains = [ "INPUT" ]
+```
+
+### Measurements & Fields:
+
+
+- iptables
+    - pkts (integer, count)
+    - bytes (integer, bytes)
+
+### Tags:
+
+- All measurements have the following tags:
+    - table
+    - chain
+    - ruleid
+
+The `ruleid` is the comment associated to the rule.
+
+### Example Output:
+
+```
+$ iptables -nvL INPUT
+Chain INPUT (policy DROP 0 packets, 0 bytes)
+pkts bytes target     prot opt in     out     source               destination
+100   1024   ACCEPT     tcp  --  *      *       192.168.0.0/24       0.0.0.0/0            tcp dpt:22 /* ssh */
+ 42   2048   ACCEPT     tcp  --  *      *       192.168.0.0/24       0.0.0.0/0            tcp dpt:80 /* httpd */
+```
+
+```
+$ ./telegraf -config telegraf.conf -input-filter iptables -test
+iptables,table=filter,chain=INPUT,ruleid=ssh pkts=100i,bytes=1024i 1453831884664956455
+iptables,table=filter,chain=INPUT,ruleid=httpd pkts=42i,bytes=2048i 1453831884664956455
+```

plugins/inputs/iptables/iptables.go

@@ -0,0 +1,128 @@
+// +build linux
+
+package iptables
+
+import (
+	"errors"
+	"os/exec"
+	"regexp"
+	"strconv"
+	"strings"
+
+	"github.com/influxdata/telegraf"
+	"github.com/influxdata/telegraf/plugins/inputs"
+)
+
+// Iptables is a telegraf plugin to gather packets and bytes throughput from Linux's iptables packet filter.
+type Iptables struct {
+	UseSudo bool
+	Table   string
+	Chains  []string
+	lister  chainLister
+}
+
+// Description returns a short description of the plugin.
+func (ipt *Iptables) Description() string {
+	return "Gather packets and bytes throughput from iptables"
+}
+
+// SampleConfig returns sample configuration options.
+func (ipt *Iptables) SampleConfig() string {
+	return `
+  ## iptables require root access on most systems.
+  ## Setting 'use_sudo' to true will make use of sudo to run iptables.
+  ## Users must configure sudo to allow telegraf user to run iptables with no password.
+  ## iptables can be restricted to only list command  "iptables -nvL"
+  use_sudo = false
+  ## defines the table to monitor:
+  table = "filter"
+  ## defines the chains to monitor:
+  chains = [ "INPUT" ]
+`
+}
+
+// Gather gathers iptables packets and bytes throughput from the configured tables and chains.
+func (ipt *Iptables) Gather(acc telegraf.Accumulator) error {
+	if ipt.Table == "" || len(ipt.Chains) == 0 {
+		return nil
+	}
+	// best effort : we continue through the chains even if an error is encountered,
+	// but we keep track of the last error.
+	var err error
+	for _, chain := range ipt.Chains {
+		data, e := ipt.lister(ipt.Table, chain)
+		if e != nil {
+			err = e
+			continue
+		}
+		e = ipt.parseAndGather(data, acc)
+		if e != nil {
+			err = e
+			continue
+		}
+	}
+	return err
+}
+
+func (ipt *Iptables) chainList(table, chain string) (string, error) {
+	iptablePath, err := exec.LookPath("iptables")
+	if err != nil {
+		return "", err
+	}
+	var args []string
+	name := iptablePath
+	if ipt.UseSudo {
+		name = "sudo"
+		args = append(args, iptablePath)
+	}
+	args = append(args, "-nvL", chain, "-t", table, "-x")
+	c := exec.Command(name, args...)
+	out, err := c.Output()
+	return string(out), err
+}
+
+const measurement = "iptables"
+
+var errParse = errors.New("Cannot parse iptables list information")
+var chainNameRe = regexp.MustCompile(`^Chain\s+(\S+)`)
+var fieldsHeaderRe = regexp.MustCompile(`^\s*pkts\s+bytes\s+`)
+var valuesRe = regexp.MustCompile(`^\s*([0-9]+)\s+([0-9]+)\s+.*?(/\*\s(.*)\s\*/)?$`)
+
+func (ipt *Iptables) parseAndGather(data string, acc telegraf.Accumulator) error {
+	lines := strings.Split(data, "\n")
+	if len(lines) < 3 {
+		return nil
+	}
+	mchain := chainNameRe.FindStringSubmatch(lines[0])
+	if mchain == nil {
+		return errParse
+	}
+	if !fieldsHeaderRe.MatchString(lines[1]) {
+		return errParse
+	}
+	for _, line := range lines[2:] {
+		mv := valuesRe.FindAllStringSubmatch(line, -1)
+		// best effort : if line does not match or rule is not commented forget about it
+		if len(mv) == 0 || len(mv[0]) != 5 || mv[0][4] == "" {
+			continue
+		}
+		tags := map[string]string{"table": ipt.Table, "chain": mchain[1], "ruleid": mv[0][4]}
+		fields := make(map[string]interface{})
+		// since parse error is already catched by the regexp,
+		// we never enter ther error case here => no error check (but still need a test to cover the case)
+		fields["pkts"], _ = strconv.ParseUint(mv[0][1], 10, 64)
+		fields["bytes"], _ = strconv.ParseUint(mv[0][2], 10, 64)
+		acc.AddFields(measurement, fields, tags)
+	}
+	return nil
+}
+
+type chainLister func(table, chain string) (string, error)
+
+func init() {
+	inputs.Add("iptables", func() telegraf.Input {
+		ipt := new(Iptables)
+		ipt.lister = ipt.chainList
+		return ipt
+	})
+}

plugins/inputs/iptables/iptables_nocompile.go

@@ -0,0 +1,3 @@
+// +build !linux
+
+package iptables

plugins/inputs/iptables/iptables_test.go

@@ -0,0 +1,206 @@
+// +build linux
+
+package iptables
+
+import (
+	"errors"
+	"reflect"
+	"testing"
+
+	"github.com/influxdata/telegraf/testutil"
+)
+
+func TestIptables_Gather(t *testing.T) {
+	tests := []struct {
+		table  string
+		chains []string
+		values []string
+		tags   []map[string]string
+		fields [][]map[string]interface{}
+		err    error
+	}{
+		{ // 1 - no configured table => no results
+			values: []string{
+				`Chain INPUT (policy ACCEPT 58 packets, 5096 bytes)
+		                pkts      bytes target     prot opt in     out     source               destination
+		                57     4520 RETURN     tcp  --  *      *       0.0.0.0/0            0.0.0.0/0
+		                `},
+		},
+		{ // 2 - no configured chains => no results
+			table: "filter",
+			values: []string{
+				`Chain INPUT (policy ACCEPT 58 packets, 5096 bytes)
+		                pkts      bytes target     prot opt in     out     source               destination
+		                57     4520 RETURN     tcp  --  *      *       0.0.0.0/0            0.0.0.0/0
+		                `},
+		},
+		{ // 3 - pkts and bytes are gathered as integers
+			table:  "filter",
+			chains: []string{"INPUT"},
+			values: []string{
+				`Chain INPUT (policy ACCEPT 58 packets, 5096 bytes)
+		                pkts      bytes target     prot opt in     out     source               destination
+		                57     4520 RETURN     tcp  --  *      *       0.0.0.0/0            0.0.0.0/0   /* foobar */
+		                `},
+			tags: []map[string]string{map[string]string{"table": "filter", "chain": "INPUT", "ruleid": "foobar"}},
+			fields: [][]map[string]interface{}{
+				{map[string]interface{}{"pkts": uint64(57), "bytes": uint64(4520)}},
+			},
+		},
+		{ // 4 - missing fields header => no results
+			table:  "filter",
+			chains: []string{"INPUT"},
+			values: []string{`Chain INPUT (policy ACCEPT 58 packets, 5096 bytes)`},
+		},
+		{ // 5 - invalid chain header => error
+			table:  "filter",
+			chains: []string{"INPUT"},
+			values: []string{
+				`INPUT (policy ACCEPT 58 packets, 5096 bytes)
+		                pkts      bytes target     prot opt in     out     source               destination
+		                57     4520 RETURN     tcp  --  *      *       0.0.0.0/0            0.0.0.0/0
+		                `},
+			err: errParse,
+		},
+		{ // 6 - invalid fields header => error
+			table:  "filter",
+			chains: []string{"INPUT"},
+			values: []string{
+				`Chain INPUT (policy ACCEPT 58 packets, 5096 bytes)
+
+		                57     4520 RETURN     tcp  --  *      *       0.0.0.0/0            0.0.0.0/0
+		                `},
+			err: errParse,
+		},
+		{ // 7 - invalid integer value => best effort, no error
+			table:  "filter",
+			chains: []string{"INPUT"},
+			values: []string{
+				`Chain INPUT (policy ACCEPT 58 packets, 5096 bytes)
+		                pkts      bytes target     prot opt in     out     source               destination
+		                K     4520 RETURN     tcp  --  *      *       0.0.0.0/0            0.0.0.0/0
+            `},
+		},
+		{ // 8 - Multiple rows, multipe chains => no error
+			table:  "filter",
+			chains: []string{"INPUT", "FORWARD"},
+			values: []string{
+				`Chain INPUT (policy ACCEPT 58 packets, 5096 bytes)
+		                pkts      bytes target     prot opt in     out     source               destination
+		                100     4520 RETURN     tcp  --  *      *       0.0.0.0/0            0.0.0.0/0
+		                200     4520 RETURN     tcp  --  *      *       0.0.0.0/0            0.0.0.0/0  /* foo */
+		                `,
+				`Chain FORWARD (policy ACCEPT 58 packets, 5096 bytes)
+		                pkts      bytes target     prot opt in     out     source               destination
+		                300     4520 RETURN     tcp  --  *      *       0.0.0.0/0            0.0.0.0/0  /* bar */
+		                400     4520 RETURN     tcp  --  *      *       0.0.0.0/0            0.0.0.0/0 
+		                500     4520 RETURN     tcp  --  *      *       0.0.0.0/0            0.0.0.0/0 /* foobar */
+		                `,
+			},
+			tags: []map[string]string{
+				map[string]string{"table": "filter", "chain": "INPUT", "ruleid": "foo"},
+				map[string]string{"table": "filter", "chain": "FORWARD", "ruleid": "bar"},
+				map[string]string{"table": "filter", "chain": "FORWARD", "ruleid": "foobar"},
+			},
+			fields: [][]map[string]interface{}{
+				{map[string]interface{}{"pkts": uint64(200), "bytes": uint64(4520)}},
+				{map[string]interface{}{"pkts": uint64(300), "bytes": uint64(4520)}},
+				{map[string]interface{}{"pkts": uint64(500), "bytes": uint64(4520)}},
+			},
+		},
+		{ // 9 - comments are used as ruleid if any
+			table:  "filter",
+			chains: []string{"INPUT"},
+			values: []string{
+				`Chain INPUT (policy ACCEPT 58 packets, 5096 bytes)
+		                pkts      bytes target     prot opt in     out     source               destination
+                        57     4520 RETURN     tcp  --  *      *       0.0.0.0/0            0.0.0.0/0             tcp dpt:22 /* foobar */
+                        100     4520 RETURN     tcp  --  *      *       0.0.0.0/0            0.0.0.0/0    tcp dpt:80
+		                `},
+			tags: []map[string]string{
+				map[string]string{"table": "filter", "chain": "INPUT", "ruleid": "foobar"},
+			},
+			fields: [][]map[string]interface{}{
+				{map[string]interface{}{"pkts": uint64(57), "bytes": uint64(4520)}},
+			},
+		},
+	}
+
+	for i, tt := range tests {
+		i++
+		ipt := &Iptables{
+			Table:  tt.table,
+			Chains: tt.chains,
+			lister: func(table, chain string) (string, error) {
+				if len(tt.values) > 0 {
+					v := tt.values[0]
+					tt.values = tt.values[1:]
+					return v, nil
+				}
+				return "", nil
+			},
+		}
+		acc := new(testutil.Accumulator)
+		err := ipt.Gather(acc)
+		if !reflect.DeepEqual(tt.err, err) {
+			t.Errorf("%d: expected error '%#v' got '%#v'", i, tt.err, err)
+		}
+		if tt.table == "" {
+			n := acc.NFields()
+			if n != 0 {
+				t.Errorf("%d: expected 0 fields if empty table got %d", i, n)
+			}
+			continue
+		}
+		if len(tt.chains) == 0 {
+			n := acc.NFields()
+			if n != 0 {
+				t.Errorf("%d: expected 0 fields if empty chains got %d", i, n)
+			}
+			continue
+		}
+		if len(tt.tags) == 0 {
+			n := acc.NFields()
+			if n != 0 {
+				t.Errorf("%d: expected 0 values got %d", i, n)
+			}
+			continue
+		}
+		n := 0
+		for j, tags := range tt.tags {
+			for k, fields := range tt.fields[j] {
+				if len(acc.Metrics) < n+1 {
+					t.Errorf("%d: expected at least %d values got %d", i, n+1, len(acc.Metrics))
+					break
+				}
+				m := acc.Metrics[n]
+				if !reflect.DeepEqual(m.Measurement, measurement) {
+					t.Errorf("%d %d %d: expected measurement '%#v' got '%#v'\n", i, j, k, measurement, m.Measurement)
+				}
+				if !reflect.DeepEqual(m.Tags, tags) {
+					t.Errorf("%d %d %d: expected tags\n%#v got\n%#v\n", i, j, k, tags, m.Tags)
+				}
+				if !reflect.DeepEqual(m.Fields, fields) {
+					t.Errorf("%d %d %d: expected fields\n%#v got\n%#v\n", i, j, k, fields, m.Fields)
+				}
+				n++
+			}
+		}
+	}
+}
+
+func TestIptables_Gather_listerError(t *testing.T) {
+	errFoo := errors.New("error foobar")
+	ipt := &Iptables{
+		Table:  "nat",
+		Chains: []string{"foo", "bar"},
+		lister: func(table, chain string) (string, error) {
+			return "", errFoo
+		},
+	}
+	acc := new(testutil.Accumulator)
+	err := ipt.Gather(acc)
+	if !reflect.DeepEqual(err, errFoo) {
+		t.Errorf("Expected error %#v got\n%#v\n", errFoo, err)
+	}
+}

plugins/inputs/jolokia/jolokia.go

@@ -52,6 +52,7 @@ type Jolokia struct {
 
 const sampleConfig = `
   ## This is the context root used to compose the jolokia url
+  ## NOTE that your jolokia security policy must allow for POST requests.
   context = "/jolokia"
 
   ## This specifies the mode used
@@ -104,7 +105,6 @@ func (j *Jolokia) Description() string {
 }
 
 func (j *Jolokia) doRequest(req *http.Request) (map[string]interface{}, error) {
-
 	resp, err := j.jClient.MakeRequest(req)
 	if err != nil {
 		return nil, err

plugins/inputs/kafka_consumer/kafka_consumer.go

@@ -90,7 +90,7 @@ func (k *Kafka) Start(acc telegraf.Accumulator) error {
 	case "newest":
 		config.Offsets.Initial = sarama.OffsetNewest
 	default:
-		log.Printf("WARNING: Kafka consumer invalid offset '%s', using 'oldest'\n",
+		log.Printf("I! WARNING: Kafka consumer invalid offset '%s', using 'oldest'\n",
 			k.Offset)
 		config.Offsets.Initial = sarama.OffsetOldest
 	}
@@ -115,7 +115,7 @@ func (k *Kafka) Start(acc telegraf.Accumulator) error {
 
 	// Start the kafka message reader
 	go k.receiver()
-	log.Printf("Started the kafka consumer service, peers: %v, topics: %v\n",
+	log.Printf("I! Started the kafka consumer service, peers: %v, topics: %v\n",
 		k.ZookeeperPeers, k.Topics)
 	return nil
 }
@@ -128,11 +128,13 @@ func (k *Kafka) receiver() {
 		case <-k.done:
 			return
 		case err := <-k.errs:
-			log.Printf("Kafka Consumer Error: %s\n", err.Error())
+			if err != nil {
+				log.Printf("E! Kafka Consumer Error: %s\n", err)
+			}
 		case msg := <-k.in:
 			metrics, err := k.parser.Parse(msg.Value)
 			if err != nil {
-				log.Printf("KAFKA PARSE ERROR\nmessage: %s\nerror: %s",
+				log.Printf("E! Kafka Message Parse Error\nmessage: %s\nerror: %s",
 					string(msg.Value), err.Error())
 			}
 
@@ -156,7 +158,7 @@ func (k *Kafka) Stop() {
 	defer k.Unlock()
 	close(k.done)
 	if err := k.Consumer.Close(); err != nil {
-		log.Printf("Error closing kafka consumer: %s\n", err.Error())
+		log.Printf("E! Error closing kafka consumer: %s\n", err.Error())
 	}
 }
 

plugins/inputs/kafka_consumer/kafka_consumer_test.go

@@ -43,7 +43,7 @@ func TestRunParser(t *testing.T) {
 	k.parser, _ = parsers.NewInfluxParser()
 	go k.receiver()
 	in <- saramaMsg(testMsg)
-	time.Sleep(time.Millisecond)
+	time.Sleep(time.Millisecond * 5)
 
 	assert.Equal(t, acc.NFields(), 1)
 }
@@ -58,7 +58,7 @@ func TestRunParserInvalidMsg(t *testing.T) {
 	k.parser, _ = parsers.NewInfluxParser()
 	go k.receiver()
 	in <- saramaMsg(invalidMsg)
-	time.Sleep(time.Millisecond)
+	time.Sleep(time.Millisecond * 5)
 
 	assert.Equal(t, acc.NFields(), 0)
 }
@@ -73,7 +73,7 @@ func TestRunParserAndGather(t *testing.T) {
 	k.parser, _ = parsers.NewInfluxParser()
 	go k.receiver()
 	in <- saramaMsg(testMsg)
-	time.Sleep(time.Millisecond)
+	time.Sleep(time.Millisecond * 5)
 
 	k.Gather(&acc)
 
@@ -92,7 +92,7 @@ func TestRunParserAndGatherGraphite(t *testing.T) {
 	k.parser, _ = parsers.NewGraphiteParser("_", []string{}, nil)
 	go k.receiver()
 	in <- saramaMsg(testMsgGraphite)
-	time.Sleep(time.Millisecond)
+	time.Sleep(time.Millisecond * 5)
 
 	k.Gather(&acc)
 
@@ -111,7 +111,7 @@ func TestRunParserAndGatherJSON(t *testing.T) {
 	k.parser, _ = parsers.NewJSONParser("kafka_json_test", []string{}, nil)
 	go k.receiver()
 	in <- saramaMsg(testMsgJSON)
-	time.Sleep(time.Millisecond)
+	time.Sleep(time.Millisecond * 5)
 
 	k.Gather(&acc)
 

plugins/inputs/logparser/grok/grok.go

@@ -202,21 +202,21 @@ func (p *Parser) ParseLine(line string) (telegraf.Metric, error) {
 		case INT:
 			iv, err := strconv.ParseInt(v, 10, 64)
 			if err != nil {
-				log.Printf("ERROR parsing %s to int: %s", v, err)
+				log.Printf("E! Error parsing %s to int: %s", v, err)
 			} else {
 				fields[k] = iv
 			}
 		case FLOAT:
 			fv, err := strconv.ParseFloat(v, 64)
 			if err != nil {
-				log.Printf("ERROR parsing %s to float: %s", v, err)
+				log.Printf("E! Error parsing %s to float: %s", v, err)
 			} else {
 				fields[k] = fv
 			}
 		case DURATION:
 			d, err := time.ParseDuration(v)
 			if err != nil {
-				log.Printf("ERROR parsing %s to duration: %s", v, err)
+				log.Printf("E! Error parsing %s to duration: %s", v, err)
 			} else {
 				fields[k] = int64(d)
 			}
@@ -227,14 +227,14 @@ func (p *Parser) ParseLine(line string) (telegraf.Metric, error) {
 		case EPOCH:
 			iv, err := strconv.ParseInt(v, 10, 64)
 			if err != nil {
-				log.Printf("ERROR parsing %s to int: %s", v, err)
+				log.Printf("E! Error parsing %s to int: %s", v, err)
 			} else {
 				timestamp = time.Unix(iv, 0)
 			}
 		case EPOCH_NANO:
 			iv, err := strconv.ParseInt(v, 10, 64)
 			if err != nil {
-				log.Printf("ERROR parsing %s to int: %s", v, err)
+				log.Printf("E! Error parsing %s to int: %s", v, err)
 			} else {
 				timestamp = time.Unix(0, iv)
 			}
@@ -265,7 +265,7 @@ func (p *Parser) ParseLine(line string) (telegraf.Metric, error) {
 			// if we still haven't found a timestamp layout, log it and we will
 			// just use time.Now()
 			if !foundTs {
-				log.Printf("ERROR parsing timestamp [%s], could not find any "+
+				log.Printf("E! Error parsing timestamp [%s], could not find any "+
 					"suitable time layouts.", v)
 			}
 		case DROP:
@@ -275,7 +275,7 @@ func (p *Parser) ParseLine(line string) (telegraf.Metric, error) {
 			if err == nil {
 				timestamp = ts
 			} else {
-				log.Printf("ERROR parsing %s to time layout [%s]: %s", v, t, err)
+				log.Printf("E! Error parsing %s to time layout [%s]: %s", v, t, err)
 			}
 		}
 	}

plugins/inputs/logparser/logparser.go

@@ -134,7 +134,7 @@ func (l *LogParserPlugin) Start(acc telegraf.Accumulator) error {
 	for _, filepath := range l.Files {
 		g, err := globpath.Compile(filepath)
 		if err != nil {
-			log.Printf("ERROR Glob %s failed to compile, %s", filepath, err)
+			log.Printf("E! Error Glob %s failed to compile, %s", filepath, err)
 			continue
 		}
 		files := g.Match()
@@ -167,7 +167,7 @@ func (l *LogParserPlugin) receiver(tailer *tail.Tail) {
 	var line *tail.Line
 	for line = range tailer.Lines {
 		if line.Err != nil {
-			log.Printf("ERROR tailing file %s, Error: %s\n",
+			log.Printf("E! Error tailing file %s, Error: %s\n",
 				tailer.Filename, line.Err)
 			continue
 		}
@@ -216,7 +216,7 @@ func (l *LogParserPlugin) Stop() {
 	for _, t := range l.tailers {
 		err := t.Stop()
 		if err != nil {
-			log.Printf("ERROR stopping tail on file %s\n", t.Filename)
+			log.Printf("E! Error stopping tail on file %s\n", t.Filename)
 		}
 		t.Cleanup()
 	}

plugins/inputs/mailchimp/chimp_api.go

@@ -134,7 +134,7 @@ func runChimp(api *ChimpAPI, params ReportsParams) ([]byte, error) {
 	req.URL.RawQuery = params.String()
 	req.Header.Set("User-Agent", "Telegraf-MailChimp-Plugin")
 	if api.Debug {
-		log.Printf("Request URL: %s", req.URL.String())
+		log.Printf("D! Request URL: %s", req.URL.String())
 	}
 
 	resp, err := client.Do(req)
@@ -148,7 +148,7 @@ func runChimp(api *ChimpAPI, params ReportsParams) ([]byte, error) {
 		return nil, err
 	}
 	if api.Debug {
-		log.Printf("Response Body:%s", string(body))
+		log.Printf("D! Response Body:%s", string(body))
 	}
 
 	if err = chimpErrorCheck(body); err != nil {

plugins/inputs/mesos/README.md

@@ -35,13 +35,10 @@ For more information, please check the [Mesos Observability Metrics](http://meso
   #   "tasks",
   #   "messages",
   # ]
-  ## Include mesos tasks statistics, default is false
-  # slave_tasks = true
 ```
 
 By default this plugin is not configured to gather metrics from mesos. Since a mesos cluster can be deployed in numerous ways it does not provide any default
-values. User needs to specify master/slave nodes this plugin will gather metrics from. Additionally, enabling `slave_tasks` will allow
-gathering metrics from tasks running on specified slaves (this option is disabled by default).
+values. User needs to specify master/slave nodes this plugin will gather metrics from.
 
 ### Measurements & Fields:
 
@@ -235,45 +232,21 @@ Mesos slave metric groups
     - slave/valid_framework_messages
     - slave/valid_status_updates
 
-Mesos tasks metric groups
-
-- executor_id
-- executor_name
-- framework_id
-- source
-- statistics (all metrics below will have `statistics_` prefix included in their names
-    - cpus_limit
-    - cpus_system_time_secs
-    - cpus_user_time_secs
-    - mem_anon_bytes
-    - mem_cache_bytes
-    - mem_critical_pressure_counter
-    - mem_file_bytes
-    - mem_limit_bytes
-    - mem_low_pressure_counter
-    - mem_mapped_file_bytes
-    - mem_medium_pressure_counter
-    - mem_rss_bytes
-    - mem_swap_bytes
-    - mem_total_bytes
-    - mem_total_memsw_bytes
-    - mem_unevictable_bytes
-    - timestamp
-
 ### Tags:
 
 - All master/slave measurements have the following tags:
     - server
     - role (master/slave)
 
-- Tasks  measurements have the following tags:
-    - server
+- All master measurements have the extra tags:
+	- state (leader/follower)
 
 ### Example Output:
 ```
 $ telegraf -config ~/mesos.conf -input-filter mesos -test
 * Plugin: mesos, Collection 1
-mesos,host=172.17.8.102,server=172.17.8.101 allocator/event_queue_dispatches=0,master/cpus_percent=0,
+mesos,role=master,state=leader,host=172.17.8.102,server=172.17.8.101
+allocator/event_queue_dispatches=0,master/cpus_percent=0,
 master/cpus_revocable_percent=0,master/cpus_revocable_total=0,
 master/cpus_revocable_used=0,master/cpus_total=2,
 master/cpus_used=0,master/disk_percent=0,master/disk_revocable_percent=0,
@@ -291,15 +264,3 @@ master/mem_used=0,master/messages_authenticate=0,
 master/messages_deactivate_framework=0 ...
 ```
 
-Meoso tasks metrics (if enabled):
-```
-mesos-tasks,host=172.17.8.102,server=172.17.8.101,task_id=hello-world.e4b5b497-2ccd-11e6-a659-0242fb222ce2
-statistics_cpus_limit=0.2,statistics_cpus_system_time_secs=142.49,statistics_cpus_user_time_secs=388.14,
-statistics_mem_anon_bytes=359129088,statistics_mem_cache_bytes=3964928,
-statistics_mem_critical_pressure_counter=0,statistics_mem_file_bytes=3964928,
-statistics_mem_limit_bytes=767557632,statistics_mem_low_pressure_counter=0,
-statistics_mem_mapped_file_bytes=114688,statistics_mem_medium_pressure_counter=0,
-statistics_mem_rss_bytes=359129088,statistics_mem_swap_bytes=0,statistics_mem_total_bytes=363094016,
-statistics_mem_total_memsw_bytes=363094016,statistics_mem_unevictable_bytes=0,
-statistics_timestamp=1465486052.70525 1465486053052811792...
-```

plugins/inputs/mesos/mesos.go

@@ -30,7 +30,7 @@ type Mesos struct {
 	MasterCols []string `toml:"master_collections"`
 	Slaves     []string
 	SlaveCols  []string `toml:"slave_collections"`
-	SlaveTasks bool
+	//SlaveTasks bool
 }
 
 var allMetrics = map[Role][]string{
@@ -66,8 +66,6 @@ var sampleConfig = `
   #   "tasks",
   #   "messages",
   # ]
-  ## Include mesos tasks statistics, default is false
-  # slave_tasks = true
 `
 
 // SampleConfig returns a sample configuration block
@@ -90,7 +88,7 @@ func (m *Mesos) SetDefaults() {
 	}
 
 	if m.Timeout == 0 {
-		log.Println("[mesos] Missing timeout value, setting default value (100ms)")
+		log.Println("I! [mesos] Missing timeout value, setting default value (100ms)")
 		m.Timeout = 100
 	}
 }
@@ -116,21 +114,21 @@ func (m *Mesos) Gather(acc telegraf.Accumulator) error {
 	for _, v := range m.Slaves {
 		wg.Add(1)
 		go func(c string) {
-			errorChannel <- m.gatherMainMetrics(c, ":5051", MASTER, acc)
+			errorChannel <- m.gatherMainMetrics(c, ":5051", SLAVE, acc)
 			wg.Done()
 			return
 		}(v)
 
-		if !m.SlaveTasks {
-			continue
-		}
+		// if !m.SlaveTasks {
+		// 	continue
+		// }
 
-		wg.Add(1)
-		go func(c string) {
-			errorChannel <- m.gatherSlaveTaskMetrics(c, ":5051", acc)
-			wg.Done()
-			return
-		}(v)
+		// wg.Add(1)
+		// go func(c string) {
+		// 	errorChannel <- m.gatherSlaveTaskMetrics(c, ":5051", acc)
+		// 	wg.Done()
+		// 	return
+		// }(v)
 	}
 
 	wg.Wait()
@@ -385,7 +383,7 @@ func getMetrics(role Role, group string) []string {
 	ret, ok := m[group]
 
 	if !ok {
-		log.Printf("[mesos] Unkown %s metrics group: %s\n", role, group)
+		log.Printf("I! [mesos] Unkown %s metrics group: %s\n", role, group)
 		return []string{}
 	}
 
@@ -420,8 +418,15 @@ var client = &http.Client{
 	Timeout:   time.Duration(4 * time.Second),
 }
 
+// TaskStats struct for JSON API output /monitor/statistics
+type TaskStats struct {
+	ExecutorID  string                 `json:"executor_id"`
+	FrameworkID string                 `json:"framework_id"`
+	Statistics  map[string]interface{} `json:"statistics"`
+}
+
 func (m *Mesos) gatherSlaveTaskMetrics(address string, defaultPort string, acc telegraf.Accumulator) error {
-	var metrics []map[string]interface{}
+	var metrics []TaskStats
 
 	host, _, err := net.SplitHostPort(address)
 	if err != nil {
@@ -452,16 +457,19 @@ func (m *Mesos) gatherSlaveTaskMetrics(address string, defaultPort string, acc t
 	}
 
 	for _, task := range metrics {
-		tags["task_id"] = task["executor_id"].(string)
+		tags["framework_id"] = task.FrameworkID
 
 		jf := jsonparser.JSONFlattener{}
-		err = jf.FlattenJSON("", task)
+		err = jf.FlattenJSON("", task.Statistics)
 
 		if err != nil {
 			return err
 		}
 
-		acc.AddFields("mesos-tasks", jf.Fields, tags)
+		timestamp := time.Unix(int64(jf.Fields["timestamp"].(float64)), 0)
+		jf.Fields["executor_id"] = task.ExecutorID
+
+		acc.AddFields("mesos_tasks", jf.Fields, tags, timestamp)
 	}
 
 	return nil
@@ -510,6 +518,14 @@ func (m *Mesos) gatherMainMetrics(a string, defaultPort string, role Role, acc t
 		return err
 	}
 
+	if role == MASTER {
+		if jf.Fields["master/elected"] != 0.0 {
+			tags["state"] = "leader"
+		} else {
+			tags["state"] = "standby"
+		}
+	}
+
 	acc.AddFields("mesos", jf.Fields, tags)
 
 	return nil

plugins/inputs/mesos/mesos_test.go

@@ -9,14 +9,14 @@ import (
 	"os"
 	"testing"
 
-	jsonparser "github.com/influxdata/telegraf/plugins/parsers/json"
 	"github.com/influxdata/telegraf/testutil"
 )
 
 var masterMetrics map[string]interface{}
 var masterTestServer *httptest.Server
 var slaveMetrics map[string]interface{}
-var slaveTaskMetrics map[string]interface{}
+
+// var slaveTaskMetrics map[string]interface{}
 var slaveTestServer *httptest.Server
 
 func randUUID() string {
@@ -216,31 +216,31 @@ func generateMetrics() {
 		slaveMetrics[k] = rand.Float64()
 	}
 
-	slaveTaskMetrics = map[string]interface{}{
-		"executor_id":   fmt.Sprintf("task_%s", randUUID()),
-		"executor_name": "Some task description",
-		"framework_id":  randUUID(),
-		"source":        fmt.Sprintf("task_source_%s", randUUID()),
-		"statistics": map[string]interface{}{
-			"cpus_limit":                    rand.Float64(),
-			"cpus_system_time_secs":         rand.Float64(),
-			"cpus_user_time_secs":           rand.Float64(),
-			"mem_anon_bytes":                float64(rand.Int63()),
-			"mem_cache_bytes":               float64(rand.Int63()),
-			"mem_critical_pressure_counter": float64(rand.Int63()),
-			"mem_file_bytes":                float64(rand.Int63()),
-			"mem_limit_bytes":               float64(rand.Int63()),
-			"mem_low_pressure_counter":      float64(rand.Int63()),
-			"mem_mapped_file_bytes":         float64(rand.Int63()),
-			"mem_medium_pressure_counter":   float64(rand.Int63()),
-			"mem_rss_bytes":                 float64(rand.Int63()),
-			"mem_swap_bytes":                float64(rand.Int63()),
-			"mem_total_bytes":               float64(rand.Int63()),
-			"mem_total_memsw_bytes":         float64(rand.Int63()),
-			"mem_unevictable_bytes":         float64(rand.Int63()),
-			"timestamp":                     rand.Float64(),
-		},
-	}
+	// slaveTaskMetrics = map[string]interface{}{
+	// 	"executor_id":   fmt.Sprintf("task_name.%s", randUUID()),
+	// 	"executor_name": "Some task description",
+	// 	"framework_id":  randUUID(),
+	// 	"source":        fmt.Sprintf("task_source.%s", randUUID()),
+	// 	"statistics": map[string]interface{}{
+	// 		"cpus_limit":                    rand.Float64(),
+	// 		"cpus_system_time_secs":         rand.Float64(),
+	// 		"cpus_user_time_secs":           rand.Float64(),
+	// 		"mem_anon_bytes":                float64(rand.Int63()),
+	// 		"mem_cache_bytes":               float64(rand.Int63()),
+	// 		"mem_critical_pressure_counter": float64(rand.Int63()),
+	// 		"mem_file_bytes":                float64(rand.Int63()),
+	// 		"mem_limit_bytes":               float64(rand.Int63()),
+	// 		"mem_low_pressure_counter":      float64(rand.Int63()),
+	// 		"mem_mapped_file_bytes":         float64(rand.Int63()),
+	// 		"mem_medium_pressure_counter":   float64(rand.Int63()),
+	// 		"mem_rss_bytes":                 float64(rand.Int63()),
+	// 		"mem_swap_bytes":                float64(rand.Int63()),
+	// 		"mem_total_bytes":               float64(rand.Int63()),
+	// 		"mem_total_memsw_bytes":         float64(rand.Int63()),
+	// 		"mem_unevictable_bytes":         float64(rand.Int63()),
+	// 		"timestamp":                     rand.Float64(),
+	// 	},
+	// }
 }
 
 func TestMain(m *testing.M) {
@@ -260,11 +260,11 @@ func TestMain(m *testing.M) {
 		w.Header().Set("Content-Type", "application/json")
 		json.NewEncoder(w).Encode(slaveMetrics)
 	})
-	slaveRouter.HandleFunc("/monitor/statistics", func(w http.ResponseWriter, r *http.Request) {
-		w.WriteHeader(http.StatusOK)
-		w.Header().Set("Content-Type", "application/json")
-		json.NewEncoder(w).Encode([]map[string]interface{}{slaveTaskMetrics})
-	})
+	// slaveRouter.HandleFunc("/monitor/statistics", func(w http.ResponseWriter, r *http.Request) {
+	// 	w.WriteHeader(http.StatusOK)
+	// 	w.Header().Set("Content-Type", "application/json")
+	// 	json.NewEncoder(w).Encode([]map[string]interface{}{slaveTaskMetrics})
+	// })
 	slaveTestServer = httptest.NewServer(slaveRouter)
 
 	rc := m.Run()
@@ -324,10 +324,10 @@ func TestMesosSlave(t *testing.T) {
 	var acc testutil.Accumulator
 
 	m := Mesos{
-		Masters:    []string{},
-		Slaves:     []string{slaveTestServer.Listener.Addr().String()},
-		SlaveTasks: true,
-		Timeout:    10,
+		Masters: []string{},
+		Slaves:  []string{slaveTestServer.Listener.Addr().String()},
+		// SlaveTasks: true,
+		Timeout: 10,
 	}
 
 	err := m.Gather(&acc)
@@ -338,14 +338,17 @@ func TestMesosSlave(t *testing.T) {
 
 	acc.AssertContainsFields(t, "mesos", slaveMetrics)
 
-	jf := jsonparser.JSONFlattener{}
-	err = jf.FlattenJSON("", slaveTaskMetrics)
+	// expectedFields := make(map[string]interface{}, len(slaveTaskMetrics["statistics"].(map[string]interface{}))+1)
+	// for k, v := range slaveTaskMetrics["statistics"].(map[string]interface{}) {
+	// 	expectedFields[k] = v
+	// }
+	// expectedFields["executor_id"] = slaveTaskMetrics["executor_id"]
 
-	if err != nil {
-		t.Errorf(err.Error())
-	}
-
-	acc.AssertContainsFields(t, "mesos-tasks", jf.Fields)
+	// acc.AssertContainsTaggedFields(
+	// 	t,
+	// 	"mesos_tasks",
+	// 	expectedFields,
+	// 	map[string]string{"server": "127.0.0.1", "framework_id": slaveTaskMetrics["framework_id"].(string)})
 }
 
 func TestSlaveFilter(t *testing.T) {

plugins/inputs/mongodb/mongodb_server.go

@@ -26,14 +26,28 @@ func (s *Server) gatherData(acc telegraf.Accumulator, gatherDbStats bool) error
 	s.Session.SetMode(mgo.Eventual, true)
 	s.Session.SetSocketTimeout(0)
 	result_server := &ServerStatus{}
-	err := s.Session.DB("admin").Run(bson.D{{"serverStatus", 1}, {"recordStats", 0}}, result_server)
+	err := s.Session.DB("admin").Run(bson.D{
+		{
+			Name:  "serverStatus",
+			Value: 1,
+		},
+		{
+			Name:  "recordStats",
+			Value: 0,
+		},
+	}, result_server)
 	if err != nil {
 		return err
 	}
 	result_repl := &ReplSetStatus{}
-	err = s.Session.DB("admin").Run(bson.D{{"replSetGetStatus", 1}}, result_repl)
+	err = s.Session.DB("admin").Run(bson.D{
+		{
+			Name:  "replSetGetStatus",
+			Value: 1,
+		},
+	}, result_repl)
 	if err != nil {
-		log.Println("Not gathering replica set status, member not in replica set (" + err.Error() + ")")
+		log.Println("E! Not gathering replica set status, member not in replica set (" + err.Error() + ")")
 	}
 
 	jumbo_chunks, _ := s.Session.DB("config").C("chunks").Find(bson.M{"jumbo": true}).Count()
@@ -48,13 +62,18 @@ func (s *Server) gatherData(acc telegraf.Accumulator, gatherDbStats bool) error
 		names := []string{}
 		names, err = s.Session.DatabaseNames()
 		if err != nil {
-			log.Println("Error getting database names (" + err.Error() + ")")
+			log.Println("E! Error getting database names (" + err.Error() + ")")
 		}
 		for _, db_name := range names {
 			db_stat_line := &DbStatsData{}
-			err = s.Session.DB(db_name).Run(bson.D{{"dbStats", 1}}, db_stat_line)
+			err = s.Session.DB(db_name).Run(bson.D{
+				{
+					Name:  "dbStats",
+					Value: 1,
+				},
+			}, db_stat_line)
 			if err != nil {
-				log.Println("Error getting db stats from " + db_name + "(" + err.Error() + ")")
+				log.Println("E! Error getting db stats from " + db_name + "(" + err.Error() + ")")
 			}
 			db := &Db{
 				Name:        db_name,

plugins/inputs/mongodb/mongostat.go

@@ -514,7 +514,7 @@ func NewStatLine(oldMongo, newMongo MongoStatus, key string, all bool, sampleSec
 		returnVal.Command = diff(newStat.Opcounters.Command, oldStat.Opcounters.Command, sampleSecs)
 	}
 
-	if newStat.Metrics.TTL != nil && oldStat.Metrics.TTL != nil {
+	if newStat.Metrics != nil && newStat.Metrics.TTL != nil && oldStat.Metrics.TTL != nil {
 		returnVal.Passes = diff(newStat.Metrics.TTL.Passes, oldStat.Metrics.TTL.Passes, sampleSecs)
 		returnVal.DeletedDocuments = diff(newStat.Metrics.TTL.DeletedDocuments, oldStat.Metrics.TTL.DeletedDocuments, sampleSecs)
 	}

plugins/inputs/mqtt_consumer/mqtt_consumer.go

@@ -133,7 +133,7 @@ func (m *MQTTConsumer) Start(acc telegraf.Accumulator) error {
 	return nil
 }
 func (m *MQTTConsumer) onConnect(c mqtt.Client) {
-	log.Printf("MQTT Client Connected")
+	log.Printf("I! MQTT Client Connected")
 	if !m.PersistentSession || !m.started {
 		topics := make(map[string]byte)
 		for _, topic := range m.Topics {
@@ -142,7 +142,7 @@ func (m *MQTTConsumer) onConnect(c mqtt.Client) {
 		subscribeToken := c.SubscribeMultiple(topics, m.recvMessage)
 		subscribeToken.Wait()
 		if subscribeToken.Error() != nil {
-			log.Printf("MQTT SUBSCRIBE ERROR\ntopics: %s\nerror: %s",
+			log.Printf("E! MQTT Subscribe Error\ntopics: %s\nerror: %s",
 				strings.Join(m.Topics[:], ","), subscribeToken.Error())
 		}
 		m.started = true
@@ -151,7 +151,7 @@ func (m *MQTTConsumer) onConnect(c mqtt.Client) {
 }
 
 func (m *MQTTConsumer) onConnectionLost(c mqtt.Client, err error) {
-	log.Printf("MQTT Connection lost\nerror: %s\nMQTT Client will try to reconnect", err.Error())
+	log.Printf("E! MQTT Connection lost\nerror: %s\nMQTT Client will try to reconnect", err.Error())
 	return
 }
 
@@ -166,7 +166,7 @@ func (m *MQTTConsumer) receiver() {
 			topic := msg.Topic()
 			metrics, err := m.parser.Parse(msg.Payload())
 			if err != nil {
-				log.Printf("MQTT PARSE ERROR\nmessage: %s\nerror: %s",
+				log.Printf("E! MQTT Parse Error\nmessage: %s\nerror: %s",
 					string(msg.Payload()), err.Error())
 			}
 

plugins/inputs/mysql/mysql.go

@@ -313,6 +313,10 @@ var mappings = []*mapping{
 		onServer: "wsrep_",
 		inExport: "wsrep_",
 	},
+	{
+		onServer: "Uptime_",
+		inExport: "uptime_",
+	},
 }
 
 var (
@@ -1478,19 +1482,23 @@ func (m *Mysql) gatherTableSchema(db *sql.DB, serv string, acc telegraf.Accumula
 			tags["schema"] = tableSchema
 			tags["table"] = tableName
 
-			acc.Add(newNamespace("info_schema", "table_rows"), tableRows, tags)
+			acc.AddFields(newNamespace("info_schema", "table_rows"),
+				map[string]interface{}{"value": tableRows}, tags)
 
 			dlTags := copyTags(tags)
 			dlTags["component"] = "data_length"
-			acc.Add(newNamespace("info_schema", "table_size", "data_length"), dataLength, dlTags)
+			acc.AddFields(newNamespace("info_schema", "table_size", "data_length"),
+				map[string]interface{}{"value": dataLength}, dlTags)
 
 			ilTags := copyTags(tags)
 			ilTags["component"] = "index_length"
-			acc.Add(newNamespace("info_schema", "table_size", "index_length"), indexLength, ilTags)
+			acc.AddFields(newNamespace("info_schema", "table_size", "index_length"),
+				map[string]interface{}{"value": indexLength}, ilTags)
 
 			dfTags := copyTags(tags)
 			dfTags["component"] = "data_free"
-			acc.Add(newNamespace("info_schema", "table_size", "data_free"), dataFree, dfTags)
+			acc.AddFields(newNamespace("info_schema", "table_size", "data_free"),
+				map[string]interface{}{"value": dataFree}, dfTags)
 
 			versionTags := copyTags(tags)
 			versionTags["type"] = tableType
@@ -1498,7 +1506,8 @@ func (m *Mysql) gatherTableSchema(db *sql.DB, serv string, acc telegraf.Accumula
 			versionTags["row_format"] = rowFormat
 			versionTags["create_options"] = createOptions
 
-			acc.Add(newNamespace("info_schema", "table_version"), version, versionTags)
+			acc.AddFields(newNamespace("info_schema", "table_version"),
+				map[string]interface{}{"value": version}, versionTags)
 		}
 	}
 	return nil
@@ -1511,7 +1520,7 @@ func parseValue(value sql.RawBytes) (float64, bool) {
 	}
 
 	if bytes.Compare(value, []byte("No")) == 0 || bytes.Compare(value, []byte("OFF")) == 0 {
-		return 0, false
+		return 0, true
 	}
 	n, err := strconv.ParseFloat(string(value), 64)
 	return n, err == nil

plugins/inputs/nats_consumer/nats_consumer.go

@@ -119,7 +119,7 @@ func (n *natsConsumer) Start(acc telegraf.Accumulator) error {
 
 	// Start the message reader
 	go n.receiver()
-	log.Printf("Started the NATS consumer service, nats: %v, subjects: %v, queue: %v\n",
+	log.Printf("I! Started the NATS consumer service, nats: %v, subjects: %v, queue: %v\n",
 		n.Conn.ConnectedUrl(), n.Subjects, n.QueueGroup)
 
 	return nil
@@ -134,11 +134,11 @@ func (n *natsConsumer) receiver() {
 		case <-n.done:
 			return
 		case err := <-n.errs:
-			log.Printf("error reading from %s\n", err.Error())
+			log.Printf("E! error reading from %s\n", err.Error())
 		case msg := <-n.in:
 			metrics, err := n.parser.Parse(msg.Data)
 			if err != nil {
-				log.Printf("subject: %s, error: %s", msg.Subject, err.Error())
+				log.Printf("E! subject: %s, error: %s", msg.Subject, err.Error())
 			}
 
 			for _, metric := range metrics {
@@ -157,7 +157,7 @@ func (n *natsConsumer) clean() {
 
 	for _, sub := range n.Subs {
 		if err := sub.Unsubscribe(); err != nil {
-			log.Printf("Error unsubscribing from subject %s in queue %s: %s\n",
+			log.Printf("E! Error unsubscribing from subject %s in queue %s: %s\n",
 				sub.Subject, sub.Queue, err.Error())
 		}
 	}

plugins/inputs/nsq_consumer/nsq_consumer.go

@@ -62,7 +62,7 @@ func (n *NSQConsumer) Start(acc telegraf.Accumulator) error {
 	n.consumer.AddConcurrentHandlers(nsq.HandlerFunc(func(message *nsq.Message) error {
 		metrics, err := n.parser.Parse(message.Body)
 		if err != nil {
-			log.Printf("NSQConsumer Parse Error\nmessage:%s\nerror:%s", string(message.Body), err.Error())
+			log.Printf("E! NSQConsumer Parse Error\nmessage:%s\nerror:%s", string(message.Body), err.Error())
 			return nil
 		}
 		for _, metric := range metrics {

plugins/inputs/ntpq/ntpq.go

@@ -132,7 +132,7 @@ func (n *NTPQ) Gather(acc telegraf.Accumulator) error {
 					case strings.HasSuffix(when, "h"):
 						m, err := strconv.Atoi(strings.TrimSuffix(fields[index], "h"))
 						if err != nil {
-							log.Printf("ERROR ntpq: parsing int: %s", fields[index])
+							log.Printf("E! Error ntpq: parsing int: %s", fields[index])
 							continue
 						}
 						// seconds in an hour
@@ -141,7 +141,7 @@ func (n *NTPQ) Gather(acc telegraf.Accumulator) error {
 					case strings.HasSuffix(when, "d"):
 						m, err := strconv.Atoi(strings.TrimSuffix(fields[index], "d"))
 						if err != nil {
-							log.Printf("ERROR ntpq: parsing int: %s", fields[index])
+							log.Printf("E! Error ntpq: parsing int: %s", fields[index])
 							continue
 						}
 						// seconds in a day
@@ -150,7 +150,7 @@ func (n *NTPQ) Gather(acc telegraf.Accumulator) error {
 					case strings.HasSuffix(when, "m"):
 						m, err := strconv.Atoi(strings.TrimSuffix(fields[index], "m"))
 						if err != nil {
-							log.Printf("ERROR ntpq: parsing int: %s", fields[index])
+							log.Printf("E! Error ntpq: parsing int: %s", fields[index])
 							continue
 						}
 						// seconds in a day
@@ -161,7 +161,7 @@ func (n *NTPQ) Gather(acc telegraf.Accumulator) error {
 
 				m, err := strconv.Atoi(fields[index])
 				if err != nil {
-					log.Printf("ERROR ntpq: parsing int: %s", fields[index])
+					log.Printf("E! Error ntpq: parsing int: %s", fields[index])
 					continue
 				}
 				mFields[key] = int64(m)
@@ -178,7 +178,7 @@ func (n *NTPQ) Gather(acc telegraf.Accumulator) error {
 
 				m, err := strconv.ParseFloat(fields[index], 64)
 				if err != nil {
-					log.Printf("ERROR ntpq: parsing float: %s", fields[index])
+					log.Printf("E! Error ntpq: parsing float: %s", fields[index])
 					continue
 				}
 				mFields[key] = m

plugins/inputs/postgresql/postgresql.go

@@ -17,6 +17,7 @@ import (
 type Postgresql struct {
 	Address          string
 	Databases        []string
+	IgnoredDatabases []string
 	OrderedColumns   []string
 	AllColumns       []string
 	sanitizedAddress string
@@ -40,8 +41,12 @@ var sampleConfig = `
   ##
   address = "host=localhost user=postgres sslmode=disable"
 
+  ## A  list of databases to explicitly ignore.  If not specified, metrics for all
+  ## databases are gathered.  Do NOT use with the 'databases' option.
+  # ignored_databases = ["postgres", "template0", "template1"]
+
   ## A list of databases to pull metrics about. If not specified, metrics for all
-  ## databases are gathered.
+  ## databases are gathered.  Do NOT use with the 'ignore_databases' option.
   # databases = ["app_production", "testing"]
 `
 
@@ -73,8 +78,11 @@ func (p *Postgresql) Gather(acc telegraf.Accumulator) error {
 
 	defer db.Close()
 
-	if len(p.Databases) == 0 {
+	if len(p.Databases) == 0 && len(p.IgnoredDatabases) == 0 {
 		query = `SELECT * FROM pg_stat_database`
+	} else if len(p.IgnoredDatabases) != 0 {
+		query = fmt.Sprintf(`SELECT * FROM pg_stat_database WHERE datname NOT IN ('%s')`,
+			strings.Join(p.IgnoredDatabases, "','"))
 	} else {
 		query = fmt.Sprintf(`SELECT * FROM pg_stat_database WHERE datname IN ('%s')`,
 			strings.Join(p.Databases, "','"))

plugins/inputs/postgresql/postgresql_test.go

@@ -150,3 +150,75 @@ func TestPostgresqlIgnoresUnwantedColumns(t *testing.T) {
 		assert.False(t, acc.HasMeasurement(col))
 	}
 }
+
+func TestPostgresqlDatabaseWhitelistTest(t *testing.T) {
+	if testing.Short() {
+		t.Skip("Skipping integration test in short mode")
+	}
+
+	p := &Postgresql{
+		Address: fmt.Sprintf("host=%s user=postgres sslmode=disable",
+			testutil.GetLocalHost()),
+		Databases: []string{"template0"},
+	}
+
+	var acc testutil.Accumulator
+
+	err := p.Gather(&acc)
+	require.NoError(t, err)
+
+	var foundTemplate0 = false
+	var foundTemplate1 = false
+
+	for _, pnt := range acc.Metrics {
+		if pnt.Measurement == "postgresql" {
+			if pnt.Tags["db"] == "template0" {
+				foundTemplate0 = true
+			}
+		}
+		if pnt.Measurement == "postgresql" {
+			if pnt.Tags["db"] == "template1" {
+				foundTemplate1 = true
+			}
+		}
+	}
+
+	assert.True(t, foundTemplate0)
+	assert.False(t, foundTemplate1)
+}
+
+func TestPostgresqlDatabaseBlacklistTest(t *testing.T) {
+	if testing.Short() {
+		t.Skip("Skipping integration test in short mode")
+	}
+
+	p := &Postgresql{
+		Address: fmt.Sprintf("host=%s user=postgres sslmode=disable",
+			testutil.GetLocalHost()),
+		IgnoredDatabases: []string{"template0"},
+	}
+
+	var acc testutil.Accumulator
+
+	err := p.Gather(&acc)
+	require.NoError(t, err)
+
+	var foundTemplate0 = false
+	var foundTemplate1 = false
+
+	for _, pnt := range acc.Metrics {
+		if pnt.Measurement == "postgresql" {
+			if pnt.Tags["db"] == "template0" {
+				foundTemplate0 = true
+			}
+		}
+		if pnt.Measurement == "postgresql" {
+			if pnt.Tags["db"] == "template1" {
+				foundTemplate1 = true
+			}
+		}
+	}
+
+	assert.False(t, foundTemplate0)
+	assert.True(t, foundTemplate1)
+}

plugins/inputs/postgresql_extensible/postgresql_extensible.go

@@ -269,9 +269,7 @@ func (p *Postgresql) accRow(meas_name string, row scanner, acc telegraf.Accumula
 	fields := make(map[string]interface{})
 COLUMN:
 	for col, val := range columnMap {
-		if acc.Debug() {
-			log.Printf("postgresql_extensible: column: %s = %T: %s\n", col, *val, *val)
-		}
+		log.Printf("D! postgresql_extensible: column: %s = %T: %s\n", col, *val, *val)
 		_, ignore := ignoredColumns[col]
 		if ignore || *val == nil {
 			continue

plugins/inputs/powerdns/powerdns.go

@@ -4,6 +4,7 @@ import (
 	"bufio"
 	"fmt"
 	"io"
+	"log"
 	"net"
 	"strconv"
 	"strings"
@@ -86,10 +87,7 @@ func (p *Powerdns) gatherServer(address string, acc telegraf.Accumulator) error
 	metrics := string(buf)
 
 	// Process data
-	fields, err := parseResponse(metrics)
-	if err != nil {
-		return err
-	}
+	fields := parseResponse(metrics)
 
 	// Add server socket as a tag
 	tags := map[string]string{"server": address}
@@ -99,22 +97,27 @@ func (p *Powerdns) gatherServer(address string, acc telegraf.Accumulator) error
 	return nil
 }
 
-func parseResponse(metrics string) (map[string]interface{}, error) {
+func parseResponse(metrics string) map[string]interface{} {
 	values := make(map[string]interface{})
 
 	s := strings.Split(metrics, ",")
 
 	for _, metric := range s[:len(s)-1] {
 		m := strings.Split(metric, "=")
+		if len(m) < 2 {
+			continue
+		}
 
 		i, err := strconv.ParseInt(m[1], 10, 64)
 		if err != nil {
-			return values, err
+			log.Printf("E! powerdns: Error parsing integer for metric [%s]: %s",
+				metric, err)
+			continue
 		}
 		values[m[0]] = i
 	}
 
-	return values, nil
+	return values
 }
 
 func init() {

plugins/inputs/powerdns/powerdns_test.go

@@ -25,6 +25,30 @@ var metrics = "corrupt-packets=0,deferred-cache-inserts=0,deferred-cache-lookup=
 	"key-cache-size=0,latency=26,meta-cache-size=0,qsize-q=0," +
 	"signature-cache-size=0,sys-msec=2889,uptime=86317,user-msec=2167,"
 
+// first metric has no "="
+var corruptMetrics = "corrupt-packets--0,deferred-cache-inserts=0,deferred-cache-lookup=0," +
+	"dnsupdate-answers=0,dnsupdate-changes=0,dnsupdate-queries=0," +
+	"dnsupdate-refused=0,packetcache-hit=0,packetcache-miss=1,packetcache-size=0," +
+	"query-cache-hit=0,query-cache-miss=6,rd-queries=1,recursing-answers=0," +
+	"recursing-questions=0,recursion-unanswered=0,security-status=3," +
+	"servfail-packets=0,signatures=0,tcp-answers=0,tcp-queries=0," +
+	"timedout-packets=0,udp-answers=1,udp-answers-bytes=50,udp-do-queries=0," +
+	"udp-queries=0,udp4-answers=1,udp4-queries=1,udp6-answers=0,udp6-queries=0," +
+	"key-cache-size=0,latency=26,meta-cache-size=0,qsize-q=0," +
+	"signature-cache-size=0,sys-msec=2889,uptime=86317,user-msec=2167,"
+
+// integer overflow
+var intOverflowMetrics = "corrupt-packets=18446744073709550195,deferred-cache-inserts=0,deferred-cache-lookup=0," +
+	"dnsupdate-answers=0,dnsupdate-changes=0,dnsupdate-queries=0," +
+	"dnsupdate-refused=0,packetcache-hit=0,packetcache-miss=1,packetcache-size=0," +
+	"query-cache-hit=0,query-cache-miss=6,rd-queries=1,recursing-answers=0," +
+	"recursing-questions=0,recursion-unanswered=0,security-status=3," +
+	"servfail-packets=0,signatures=0,tcp-answers=0,tcp-queries=0," +
+	"timedout-packets=0,udp-answers=1,udp-answers-bytes=50,udp-do-queries=0," +
+	"udp-queries=0,udp4-answers=1,udp4-queries=1,udp6-answers=0,udp6-queries=0," +
+	"key-cache-size=0,latency=26,meta-cache-size=0,qsize-q=0," +
+	"signature-cache-size=0,sys-msec=2889,uptime=86317,user-msec=2167,"
+
 func (s statServer) serverSocket(l net.Listener) {
 
 	for {
@@ -86,8 +110,7 @@ func TestMemcachedGeneratesMetrics(t *testing.T) {
 }
 
 func TestPowerdnsParseMetrics(t *testing.T) {
-	values, err := parseResponse(metrics)
-	require.NoError(t, err, "Error parsing memcached response")
+	values := parseResponse(metrics)
 
 	tests := []struct {
 		key   string
@@ -145,3 +168,121 @@ func TestPowerdnsParseMetrics(t *testing.T) {
 		}
 	}
 }
+
+func TestPowerdnsParseCorruptMetrics(t *testing.T) {
+	values := parseResponse(corruptMetrics)
+
+	tests := []struct {
+		key   string
+		value int64
+	}{
+		{"deferred-cache-inserts", 0},
+		{"deferred-cache-lookup", 0},
+		{"dnsupdate-answers", 0},
+		{"dnsupdate-changes", 0},
+		{"dnsupdate-queries", 0},
+		{"dnsupdate-refused", 0},
+		{"packetcache-hit", 0},
+		{"packetcache-miss", 1},
+		{"packetcache-size", 0},
+		{"query-cache-hit", 0},
+		{"query-cache-miss", 6},
+		{"rd-queries", 1},
+		{"recursing-answers", 0},
+		{"recursing-questions", 0},
+		{"recursion-unanswered", 0},
+		{"security-status", 3},
+		{"servfail-packets", 0},
+		{"signatures", 0},
+		{"tcp-answers", 0},
+		{"tcp-queries", 0},
+		{"timedout-packets", 0},
+		{"udp-answers", 1},
+		{"udp-answers-bytes", 50},
+		{"udp-do-queries", 0},
+		{"udp-queries", 0},
+		{"udp4-answers", 1},
+		{"udp4-queries", 1},
+		{"udp6-answers", 0},
+		{"udp6-queries", 0},
+		{"key-cache-size", 0},
+		{"latency", 26},
+		{"meta-cache-size", 0},
+		{"qsize-q", 0},
+		{"signature-cache-size", 0},
+		{"sys-msec", 2889},
+		{"uptime", 86317},
+		{"user-msec", 2167},
+	}
+
+	for _, test := range tests {
+		value, ok := values[test.key]
+		if !ok {
+			t.Errorf("Did not find key for metric %s in values", test.key)
+			continue
+		}
+		if value != test.value {
+			t.Errorf("Metric: %s, Expected: %d, actual: %d",
+				test.key, test.value, value)
+		}
+	}
+}
+
+func TestPowerdnsParseIntOverflowMetrics(t *testing.T) {
+	values := parseResponse(intOverflowMetrics)
+
+	tests := []struct {
+		key   string
+		value int64
+	}{
+		{"deferred-cache-inserts", 0},
+		{"deferred-cache-lookup", 0},
+		{"dnsupdate-answers", 0},
+		{"dnsupdate-changes", 0},
+		{"dnsupdate-queries", 0},
+		{"dnsupdate-refused", 0},
+		{"packetcache-hit", 0},
+		{"packetcache-miss", 1},
+		{"packetcache-size", 0},
+		{"query-cache-hit", 0},
+		{"query-cache-miss", 6},
+		{"rd-queries", 1},
+		{"recursing-answers", 0},
+		{"recursing-questions", 0},
+		{"recursion-unanswered", 0},
+		{"security-status", 3},
+		{"servfail-packets", 0},
+		{"signatures", 0},
+		{"tcp-answers", 0},
+		{"tcp-queries", 0},
+		{"timedout-packets", 0},
+		{"udp-answers", 1},
+		{"udp-answers-bytes", 50},
+		{"udp-do-queries", 0},
+		{"udp-queries", 0},
+		{"udp4-answers", 1},
+		{"udp4-queries", 1},
+		{"udp6-answers", 0},
+		{"udp6-queries", 0},
+		{"key-cache-size", 0},
+		{"latency", 26},
+		{"meta-cache-size", 0},
+		{"qsize-q", 0},
+		{"signature-cache-size", 0},
+		{"sys-msec", 2889},
+		{"uptime", 86317},
+		{"user-msec", 2167},
+	}
+
+	for _, test := range tests {
+		value, ok := values[test.key]
+		if !ok {
+			t.Errorf("Did not find key for metric %s in values", test.key)
+			continue
+		}
+		if value != test.value {
+			t.Errorf("Metric: %s, Expected: %d, actual: %d",
+				test.key, test.value, value)
+		}
+	}
+}

plugins/inputs/procstat/procstat.go

@@ -16,6 +16,7 @@ import (
 
 type Procstat struct {
 	PidFile     string `toml:"pid_file"`
+	Exact       bool
 	Exe         string
 	Pattern     string
 	Prefix      string
@@ -43,6 +44,8 @@ var sampleConfig = `
   # exe = "nginx"
   ## pattern as argument for pgrep (ie, pgrep -f <pattern>)
   # pattern = "nginx"
+  ## match the exact name of the process (ie, pgrep -xf <pattern>)
+  # exact = false
   ## user as argument for pgrep (ie, pgrep -u <user>)
   # user = "nginx"
 
@@ -66,7 +69,7 @@ func (_ *Procstat) Description() string {
 func (p *Procstat) Gather(acc telegraf.Accumulator) error {
 	err := p.createProcesses()
 	if err != nil {
-		log.Printf("Error: procstat getting process, exe: [%s]	pidfile: [%s] pattern: [%s] user: [%s] %s",
+		log.Printf("E! Error: procstat getting process, exe: [%s] pidfile: [%s] pattern: [%s] user: [%s] %s",
 			p.Exe, p.PidFile, p.Pattern, p.User, err.Error())
 	} else {
 		for pid, proc := range p.pidmap {
@@ -176,11 +179,17 @@ func (p *Procstat) pidsFromExe() ([]int32, error) {
 func (p *Procstat) pidsFromPattern() ([]int32, error) {
 	var out []int32
 	var outerr error
+	var options string
 	bin, err := exec.LookPath("pgrep")
 	if err != nil {
 		return out, fmt.Errorf("Couldn't find pgrep binary: %s", err)
 	}
-	pgrep, err := exec.Command(bin, "-f", p.Pattern).Output()
+	if p.Exact == true {
+		options = "-xf"
+	} else {
+		options = "-f"
+	}
+	pgrep, err := exec.Command(bin, options, p.Pattern).Output()
 	if err != nil {
 		return out, fmt.Errorf("Failed to execute %s. Error: '%s'", bin, err)
 	} else {

plugins/inputs/redis/redis.go

@@ -44,40 +44,9 @@ func (r *Redis) Description() string {
 }
 
 var Tracking = map[string]string{
-	"uptime_in_seconds":           "uptime",
-	"connected_clients":           "clients",
-	"used_memory":                 "used_memory",
-	"used_memory_rss":             "used_memory_rss",
-	"used_memory_peak":            "used_memory_peak",
-	"used_memory_lua":             "used_memory_lua",
-	"rdb_changes_since_last_save": "rdb_changes_since_last_save",
-	"total_connections_received":  "total_connections_received",
-	"total_commands_processed":    "total_commands_processed",
-	"instantaneous_ops_per_sec":   "instantaneous_ops_per_sec",
-	"instantaneous_input_kbps":    "instantaneous_input_kbps",
-	"instantaneous_output_kbps":   "instantaneous_output_kbps",
-	"sync_full":                   "sync_full",
-	"sync_partial_ok":             "sync_partial_ok",
-	"sync_partial_err":            "sync_partial_err",
-	"expired_keys":                "expired_keys",
-	"evicted_keys":                "evicted_keys",
-	"keyspace_hits":               "keyspace_hits",
-	"keyspace_misses":             "keyspace_misses",
-	"pubsub_channels":             "pubsub_channels",
-	"pubsub_patterns":             "pubsub_patterns",
-	"latest_fork_usec":            "latest_fork_usec",
-	"connected_slaves":            "connected_slaves",
-	"master_repl_offset":          "master_repl_offset",
-	"master_last_io_seconds_ago":  "master_last_io_seconds_ago",
-	"repl_backlog_active":         "repl_backlog_active",
-	"repl_backlog_size":           "repl_backlog_size",
-	"repl_backlog_histlen":        "repl_backlog_histlen",
-	"mem_fragmentation_ratio":     "mem_fragmentation_ratio",
-	"used_cpu_sys":                "used_cpu_sys",
-	"used_cpu_user":               "used_cpu_user",
-	"used_cpu_sys_children":       "used_cpu_sys_children",
-	"used_cpu_user_children":      "used_cpu_user_children",
-	"role": "replication_role",
+	"uptime_in_seconds": "uptime",
+	"connected_clients": "clients",
+	"role":              "replication_role",
 }
 
 var ErrProtocolError = errors.New("redis protocol error")
@@ -188,6 +157,7 @@ func gatherInfoOutput(
 	acc telegraf.Accumulator,
 	tags map[string]string,
 ) error {
+	var section string
 	var keyspace_hits, keyspace_misses uint64 = 0, 0
 
 	scanner := bufio.NewScanner(rdr)
@@ -198,7 +168,13 @@ func gatherInfoOutput(
 			break
 		}
 
-		if len(line) == 0 || line[0] == '#' {
+		if len(line) == 0 {
+			continue
+		}
+		if line[0] == '#' {
+			if len(line) > 2 {
+				section = line[2:]
+			}
 			continue
 		}
 
@@ -206,42 +182,69 @@ func gatherInfoOutput(
 		if len(parts) < 2 {
 			continue
 		}
-
 		name := string(parts[0])
-		metric, ok := Tracking[name]
-		if !ok {
-			kline := strings.TrimSpace(string(parts[1]))
-			gatherKeyspaceLine(name, kline, acc, tags)
+
+		if section == "Server" {
+			if name != "lru_clock" && name != "uptime_in_seconds" {
+				continue
+			}
+		}
+
+		if name == "mem_allocator" {
 			continue
 		}
 
+		if strings.HasSuffix(name, "_human") {
+			continue
+		}
+
+		metric, ok := Tracking[name]
+		if !ok {
+			if section == "Keyspace" {
+				kline := strings.TrimSpace(string(parts[1]))
+				gatherKeyspaceLine(name, kline, acc, tags)
+				continue
+			}
+			metric = name
+		}
+
 		val := strings.TrimSpace(parts[1])
-		ival, err := strconv.ParseUint(val, 10, 64)
 
-		if name == "keyspace_hits" {
-			keyspace_hits = ival
+		// Try parsing as a uint
+		if ival, err := strconv.ParseUint(val, 10, 64); err == nil {
+			switch name {
+			case "keyspace_hits":
+				keyspace_hits = ival
+			case "keyspace_misses":
+				keyspace_misses = ival
+			case "rdb_last_save_time":
+				// influxdb can't calculate this, so we have to do it
+				fields["rdb_last_save_time_elapsed"] = uint64(time.Now().Unix()) - ival
+			}
+			fields[metric] = ival
+			continue
 		}
 
-		if name == "keyspace_misses" {
-			keyspace_misses = ival
+		// Try parsing as an int
+		if ival, err := strconv.ParseInt(val, 10, 64); err == nil {
+			fields[metric] = ival
+			continue
 		}
 
+		// Try parsing as a float
+		if fval, err := strconv.ParseFloat(val, 64); err == nil {
+			fields[metric] = fval
+			continue
+		}
+
+		// Treat it as a string
+
 		if name == "role" {
 			tags["replication_role"] = val
 			continue
 		}
 
-		if err == nil {
-			fields[metric] = ival
-			continue
-		}
-
-		fval, err := strconv.ParseFloat(val, 64)
-		if err != nil {
-			return err
-		}
-
-		fields[metric] = fval
+		fields[metric] = val
 	}
 	var keyspace_hitrate float64 = 0.0
 	if keyspace_hits != 0 || keyspace_misses != 0 {

plugins/inputs/redis/redis_test.go

@@ -5,8 +5,10 @@ import (
 	"fmt"
 	"strings"
 	"testing"
+	"time"
 
 	"github.com/influxdata/telegraf/testutil"
+	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )
 
@@ -37,40 +39,73 @@ func TestRedis_ParseMetrics(t *testing.T) {
 
 	tags = map[string]string{"host": "redis.net", "replication_role": "master"}
 	fields := map[string]interface{}{
-		"uptime":                      uint64(238),
-		"clients":                     uint64(1),
-		"used_memory":                 uint64(1003936),
-		"used_memory_rss":             uint64(811008),
-		"used_memory_peak":            uint64(1003936),
-		"used_memory_lua":             uint64(33792),
-		"rdb_changes_since_last_save": uint64(0),
-		"total_connections_received":  uint64(2),
-		"total_commands_processed":    uint64(1),
-		"instantaneous_ops_per_sec":   uint64(0),
-		"sync_full":                   uint64(0),
-		"sync_partial_ok":             uint64(0),
-		"sync_partial_err":            uint64(0),
-		"expired_keys":                uint64(0),
-		"evicted_keys":                uint64(0),
-		"keyspace_hits":               uint64(1),
-		"keyspace_misses":             uint64(1),
-		"pubsub_channels":             uint64(0),
-		"pubsub_patterns":             uint64(0),
-		"latest_fork_usec":            uint64(0),
-		"connected_slaves":            uint64(0),
-		"master_repl_offset":          uint64(0),
-		"repl_backlog_active":         uint64(0),
-		"repl_backlog_size":           uint64(1048576),
-		"repl_backlog_histlen":        uint64(0),
-		"mem_fragmentation_ratio":     float64(0.81),
-		"instantaneous_input_kbps":    float64(876.16),
-		"instantaneous_output_kbps":   float64(3010.23),
-		"used_cpu_sys":                float64(0.14),
-		"used_cpu_user":               float64(0.05),
-		"used_cpu_sys_children":       float64(0.00),
-		"used_cpu_user_children":      float64(0.00),
-		"keyspace_hitrate":            float64(0.50),
+		"uptime":                         uint64(238),
+		"lru_clock":                      uint64(2364819),
+		"clients":                        uint64(1),
+		"client_longest_output_list":     uint64(0),
+		"client_biggest_input_buf":       uint64(0),
+		"blocked_clients":                uint64(0),
+		"used_memory":                    uint64(1003936),
+		"used_memory_rss":                uint64(811008),
+		"used_memory_peak":               uint64(1003936),
+		"used_memory_lua":                uint64(33792),
+		"mem_fragmentation_ratio":        float64(0.81),
+		"loading":                        uint64(0),
+		"rdb_changes_since_last_save":    uint64(0),
+		"rdb_bgsave_in_progress":         uint64(0),
+		"rdb_last_save_time":             uint64(1428427941),
+		"rdb_last_bgsave_status":         "ok",
+		"rdb_last_bgsave_time_sec":       int64(-1),
+		"rdb_current_bgsave_time_sec":    int64(-1),
+		"aof_enabled":                    uint64(0),
+		"aof_rewrite_in_progress":        uint64(0),
+		"aof_rewrite_scheduled":          uint64(0),
+		"aof_last_rewrite_time_sec":      int64(-1),
+		"aof_current_rewrite_time_sec":   int64(-1),
+		"aof_last_bgrewrite_status":      "ok",
+		"aof_last_write_status":          "ok",
+		"total_connections_received":     uint64(2),
+		"total_commands_processed":       uint64(1),
+		"instantaneous_ops_per_sec":      uint64(0),
+		"instantaneous_input_kbps":       float64(876.16),
+		"instantaneous_output_kbps":      float64(3010.23),
+		"rejected_connections":           uint64(0),
+		"sync_full":                      uint64(0),
+		"sync_partial_ok":                uint64(0),
+		"sync_partial_err":               uint64(0),
+		"expired_keys":                   uint64(0),
+		"evicted_keys":                   uint64(0),
+		"keyspace_hits":                  uint64(1),
+		"keyspace_misses":                uint64(1),
+		"pubsub_channels":                uint64(0),
+		"pubsub_patterns":                uint64(0),
+		"latest_fork_usec":               uint64(0),
+		"connected_slaves":               uint64(0),
+		"master_repl_offset":             uint64(0),
+		"repl_backlog_active":            uint64(0),
+		"repl_backlog_size":              uint64(1048576),
+		"repl_backlog_first_byte_offset": uint64(0),
+		"repl_backlog_histlen":           uint64(0),
+		"used_cpu_sys":                   float64(0.14),
+		"used_cpu_user":                  float64(0.05),
+		"used_cpu_sys_children":          float64(0.00),
+		"used_cpu_user_children":         float64(0.00),
+		"keyspace_hitrate":               float64(0.50),
 	}
+
+	// We have to test rdb_last_save_time_offset manually because the value is based on the time when gathered
+	for _, m := range acc.Metrics {
+		for k, v := range m.Fields {
+			if k == "rdb_last_save_time_elapsed" {
+				fields[k] = v
+			}
+		}
+	}
+	assert.InDelta(t,
+		uint64(time.Now().Unix())-fields["rdb_last_save_time"].(uint64),
+		fields["rdb_last_save_time_elapsed"].(uint64),
+		2) // allow for 2 seconds worth of offset
+
 	keyspaceTags := map[string]string{"host": "redis.net", "replication_role": "master", "database": "db0"}
 	keyspaceFields := map[string]interface{}{
 		"avg_ttl": uint64(0),

plugins/inputs/sensors/sensors.go

@@ -73,7 +73,7 @@ func (s *Sensors) parse(acc telegraf.Accumulator) error {
 			tags["chip"] = chip
 			continue
 		}
-		if !strings.HasPrefix(line, " ") {
+		if !strings.HasPrefix(line, "  ") {
 			if len(tags) > 1 {
 				acc.AddFields("sensors", fields, tags)
 			}
@@ -114,5 +114,5 @@ func init() {
 
 // snake converts string to snake case
 func snake(input string) string {
-	return strings.ToLower(strings.Replace(input, " ", "_", -1))
+	return strings.ToLower(strings.Replace(strings.TrimSpace(input), " ", "_", -1))
 }

plugins/inputs/sensors/sensors_test.go

@@ -122,6 +122,28 @@ func TestGatherDefault(t *testing.T) {
 				"temp_crit_alarm": 0.0,
 			},
 		},
+		{
+			map[string]string{
+				"chip":    "atk0110-acpi-0",
+				"feature": "vcore_voltage",
+			},
+			map[string]interface{}{
+				"in_input": 1.136,
+				"in_min":   0.800,
+				"in_max":   1.600,
+			},
+		},
+		{
+			map[string]string{
+				"chip":    "atk0110-acpi-0",
+				"feature": "+3.3_voltage",
+			},
+			map[string]interface{}{
+				"in_input": 3.360,
+				"in_min":   2.970,
+				"in_max":   3.630,
+			},
+		},
 	}
 
 	for _, test := range tests {
@@ -240,8 +262,29 @@ func TestGatherNotRemoveNumbers(t *testing.T) {
 				"temp3_crit_alarm": 0.0,
 			},
 		},
+		{
+			map[string]string{
+				"chip":    "atk0110-acpi-0",
+				"feature": "vcore_voltage",
+			},
+			map[string]interface{}{
+				"in0_input": 1.136,
+				"in0_min":   0.800,
+				"in0_max":   1.600,
+			},
+		},
+		{
+			map[string]string{
+				"chip":    "atk0110-acpi-0",
+				"feature": "+3.3_voltage",
+			},
+			map[string]interface{}{
+				"in1_input": 3.360,
+				"in1_min":   2.970,
+				"in1_max":   3.630,
+			},
+		},
 	}
-
 	for _, test := range tests {
 		acc.AssertContainsTaggedFields(t, "sensors", test.fields, test.tags)
 	}
@@ -309,6 +352,16 @@ Core 1:
   temp3_max: 82.000
   temp3_crit: 92.000
   temp3_crit_alarm: 0.000
+
+atk0110-acpi-0
+Vcore Voltage:
+  in0_input: 1.136
+  in0_min: 0.800
+  in0_max: 1.600
+ +3.3 Voltage:
+  in1_input: 3.360
+  in1_min: 2.970
+  in1_max: 3.630
 `
 
 	args := os.Args

plugins/inputs/snmp/README.md

@@ -136,6 +136,9 @@ Output measurement name.
 * `oid`:  
 OID to get. May be a numeric or textual OID.
 
+* `oid_index_suffix`:
+The OID sub-identifier to strip off so that the index can be matched against other fields in the table.
+
 * `name`:  
 Output field/tag name.
 If not specified, it defaults to the value of `oid`. If `oid` is numeric, an attempt to translate the numeric OID into a texual OID will be made.
@@ -149,6 +152,8 @@ Converts the value according to the given specification.
     - `float(X)`: Converts the input value into a float and divides by the Xth power of 10. Efficively just moves the decimal left X places. For example a value of `123` with `float(2)` will result in `1.23`.
     - `float`: Converts the value into a float with no adjustment. Same as `float(0)`.
     - `int`: Convertes the value into an integer.
+    - `hwaddr`: Converts the value to a MAC address.
+    - `ipaddr`: Converts the value to an IP address.
 
 #### Table parameters:
 * `oid`:  

plugins/inputs/snmp/snmp.go

@@ -20,25 +20,29 @@ import (
 const description = `Retrieves SNMP values from remote agents`
 const sampleConfig = `
   agents = [ "127.0.0.1:161" ]
+  ## Timeout for each SNMP query.
   timeout = "5s"
+  ## Number of retries to attempt within timeout.
+  retries = 3
+  ## SNMP version, values can be 1, 2, or 3
   version = 2
 
-  # SNMPv1 & SNMPv2 parameters
+  ## SNMP community string.
   community = "public"
 
-  # SNMPv2 & SNMPv3 parameters
-  max_repetitions = 50
+  ## The GETBULK max-repetitions parameter
+  max_repetitions = 10
 
-  # SNMPv3 parameters
+  ## SNMPv3 auth parameters
   #sec_name = "myuser"
-  #auth_protocol = "md5"         # Values: "MD5", "SHA", ""
-  #auth_password = "password123"
-  #sec_level = "authNoPriv"      # Values: "noAuthNoPriv", "authNoPriv", "authPriv"
+  #auth_protocol = "md5"      # Values: "MD5", "SHA", ""
+  #auth_password = "pass"
+  #sec_level = "authNoPriv"   # Values: "noAuthNoPriv", "authNoPriv", "authPriv"
   #context_name = ""
-  #priv_protocol = ""            # Values: "DES", "AES", ""
+  #priv_protocol = ""         # Values: "DES", "AES", ""
   #priv_password = ""
 
-  # measurement name
+  ## measurement name
   name = "system"
   [[inputs.snmp.field]]
     name = "hostname"
@@ -53,7 +57,7 @@ const sampleConfig = `
     oid = "HOST-RESOURCES-MIB::hrMemorySize"
 
   [[inputs.snmp.table]]
-    # measurement name
+    ## measurement name
     name = "remote_servers"
     inherit_tags = [ "hostname" ]
     [[inputs.snmp.table.field]]
@@ -68,7 +72,7 @@ const sampleConfig = `
       oid = ".1.0.0.0.1.2"
 
   [[inputs.snmp.table]]
-    # auto populate table's fields using the MIB
+    ## auto populate table's fields using the MIB
     oid = "HOST-RESOURCES-MIB::hrNetworkTable"
 `
 
@@ -105,7 +109,7 @@ type Snmp struct {
 	Community string
 
 	// Parameters for Version 2 & 3
-	MaxRepetitions uint
+	MaxRepetitions int
 
 	// Parameters for Version 3
 	ContextName string
@@ -184,23 +188,21 @@ func (t *Table) init() error {
 		return nil
 	}
 
-	mibPrefix := ""
-	if err := snmpTranslate(&mibPrefix, &t.Oid, &t.Name); err != nil {
-		return err
+	mibName, _, oidText, _, err := snmpTranslate(t.Oid)
+	if err != nil {
+		return Errorf(err, "translating %s", t.Oid)
 	}
+	if t.Name == "" {
+		t.Name = oidText
+	}
+	mibPrefix := mibName + "::"
+	oidFullName := mibPrefix + oidText
 
 	// first attempt to get the table's tags
 	tagOids := map[string]struct{}{}
 	// We have to guess that the "entry" oid is `t.Oid+".1"`. snmptable and snmptranslate don't seem to have a way to provide the info.
-	if out, err := execCmd("snmptranslate", "-m", "all", "-Td", t.Oid+".1"); err == nil {
+	if out, err := execCmd("snmptranslate", "-Td", oidFullName+".1"); err == nil {
 		lines := bytes.Split(out, []byte{'\n'})
-		// get the MIB name if we didn't get it above
-		if mibPrefix == "" {
-			if i := bytes.Index(lines[0], []byte("::")); i != -1 {
-				mibPrefix = string(lines[0][:i+2])
-			}
-		}
-
 		for _, line := range lines {
 			if !bytes.HasPrefix(line, []byte("  INDEX")) {
 				continue
@@ -223,7 +225,7 @@ func (t *Table) init() error {
 	}
 
 	// this won't actually try to run a query. The `-Ch` will just cause it to dump headers.
-	out, err := execCmd("snmptable", "-m", "all", "-Ch", "-Cl", "-c", "public", "127.0.0.1", t.Oid)
+	out, err := execCmd("snmptable", "-Ch", "-Cl", "-c", "public", "127.0.0.1", oidFullName)
 	if err != nil {
 		return Errorf(err, "getting table columns for %s", t.Oid)
 	}
@@ -260,12 +262,16 @@ type Field struct {
 	// off the OID prefix, and use the remainder as the index. For multiple fields
 	// to show up in the same row, they must share the same index.
 	Oid string
+	// OidIndexSuffix is the trailing sub-identifier on a table record OID that will be stripped off to get the record's index.
+	OidIndexSuffix string
 	// IsTag controls whether this OID is output as a tag or a value.
 	IsTag bool
 	// Conversion controls any type conversion that is done on the value.
 	//  "float"/"float(0)" will convert the value into a float.
 	//  "float(X)" will convert the value into a float, and then move the decimal before Xth right-most digit.
 	//  "int" will conver the value into an integer.
+	//  "hwaddr" will convert a 6-byte string to a MAC address.
+	//  "ipaddr" will convert the value to an IPv4 or IPv6 address.
 	Conversion string
 
 	initialized bool
@@ -277,8 +283,16 @@ func (f *Field) init() error {
 		return nil
 	}
 
-	if err := snmpTranslate(nil, &f.Oid, &f.Name); err != nil {
-		return err
+	_, oidNum, oidText, conversion, err := snmpTranslate(f.Oid)
+	if err != nil {
+		return Errorf(err, "translating %s", f.Oid)
+	}
+	f.Oid = oidNum
+	if f.Name == "" {
+		f.Name = oidText
+	}
+	if f.Conversion == "" {
+		f.Conversion = conversion
 	}
 
 	//TODO use textual convention conversion from the MIB
@@ -330,8 +344,8 @@ func Errorf(err error, msg string, format ...interface{}) error {
 func init() {
 	inputs.Add("snmp", func() telegraf.Input {
 		return &Snmp{
-			Retries:        5,
-			MaxRepetitions: 50,
+			Retries:        3,
+			MaxRepetitions: 10,
 			Timeout:        internal.Duration{Duration: 5 * time.Second},
 			Version:        2,
 			Community:      "public",
@@ -448,14 +462,32 @@ func (t Table) Build(gs snmpConnection, walk bool) (*RTable, error) {
 				return nil, Errorf(err, "performing get")
 			} else if pkt != nil && len(pkt.Variables) > 0 && pkt.Variables[0].Type != gosnmp.NoSuchObject {
 				ent := pkt.Variables[0]
-				ifv[ent.Name[len(oid):]] = fieldConvert(f.Conversion, ent.Value)
+				fv, err := fieldConvert(f.Conversion, ent.Value)
+				if err != nil {
+					return nil, Errorf(err, "converting %q", ent.Value)
+				}
+				ifv[""] = fv
 			}
 		} else {
 			err := gs.Walk(oid, func(ent gosnmp.SnmpPDU) error {
 				if len(ent.Name) <= len(oid) || ent.Name[:len(oid)+1] != oid+"." {
 					return NestedError{} // break the walk
 				}
-				ifv[ent.Name[len(oid):]] = fieldConvert(f.Conversion, ent.Value)
+
+				idx := ent.Name[len(oid):]
+				if f.OidIndexSuffix != "" {
+					if !strings.HasSuffix(idx, f.OidIndexSuffix) {
+						// this entry doesn't match our OidIndexSuffix. skip it
+						return nil
+					}
+					idx = idx[:len(idx)-len(f.OidIndexSuffix)]
+				}
+
+				fv, err := fieldConvert(f.Conversion, ent.Value)
+				if err != nil {
+					return Errorf(err, "converting %q", ent.Value)
+				}
+				ifv[idx] = fv
 				return nil
 			})
 			if err != nil {
@@ -610,7 +642,7 @@ func (s *Snmp) getConnection(agent string) (snmpConnection, error) {
 		}
 	}
 
-	gs.MaxRepetitions = int(s.MaxRepetitions)
+	gs.MaxRepetitions = s.MaxRepetitions
 
 	if s.Version == 3 {
 		gs.ContextName = s.ContextName
@@ -677,14 +709,16 @@ func (s *Snmp) getConnection(agent string) (snmpConnection, error) {
 //  "float"/"float(0)" will convert the value into a float.
 //  "float(X)" will convert the value into a float, and then move the decimal before Xth right-most digit.
 //  "int" will convert the value into an integer.
+//  "hwaddr" will convert the value into a MAC address.
+//  "ipaddr" will convert the value into into an IP address.
 //  "" will convert a byte slice into a string.
 // Any other conv will return the input value unchanged.
-func fieldConvert(conv string, v interface{}) interface{} {
+func fieldConvert(conv string, v interface{}) (interface{}, error) {
 	if conv == "" {
 		if bs, ok := v.([]byte); ok {
-			return string(bs)
+			return string(bs), nil
 		}
-		return v
+		return v, nil
 	}
 
 	var d int
@@ -721,7 +755,9 @@ func fieldConvert(conv string, v interface{}) interface{} {
 			vf, _ := strconv.ParseFloat(vt, 64)
 			v = vf / math.Pow10(d)
 		}
+		return v, nil
 	}
+
 	if conv == "int" {
 		switch vt := v.(type) {
 		case float32:
@@ -753,39 +789,106 @@ func fieldConvert(conv string, v interface{}) interface{} {
 		case string:
 			v, _ = strconv.Atoi(vt)
 		}
+		return v, nil
 	}
 
-	return v
+	if conv == "hwaddr" {
+		switch vt := v.(type) {
+		case string:
+			v = net.HardwareAddr(vt).String()
+		case []byte:
+			v = net.HardwareAddr(vt).String()
+		default:
+			return nil, fmt.Errorf("invalid type (%T) for hwaddr conversion", v)
+		}
+	}
+
+	if conv == "ipaddr" {
+		var ipbs []byte
+
+		switch vt := v.(type) {
+		case string:
+			ipbs = []byte(vt)
+		case []byte:
+			ipbs = vt
+		default:
+			return nil, fmt.Errorf("invalid type (%T) for ipaddr conversion", v)
+		}
+
+		switch len(ipbs) {
+		case 4, 16:
+			v = net.IP(ipbs).String()
+		default:
+			return nil, fmt.Errorf("invalid length (%d) for ipaddr conversion", len(ipbs))
+		}
+
+		return v, nil
+	}
+
+	return v, nil
 }
 
 // snmpTranslate resolves the given OID.
-// The contents of the oid parameter will be replaced with the numeric oid value.
-// If name is empty, the textual OID value is stored in it. If the textual OID cannot be translated, the numeric OID is stored instead.
-// If mibPrefix is non-nil, the MIB in which the OID was found is stored, with a suffix of "::".
-func snmpTranslate(mibPrefix *string, oid *string, name *string) error {
-	if strings.ContainsAny(*oid, ":abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ") {
-		out, err := execCmd("snmptranslate", "-m", "all", "-On", *oid)
-		if err != nil {
-			return Errorf(err, "translating %s", *oid)
-		}
-		*oid = string(bytes.TrimSuffix(out, []byte{'\n'}))
+func snmpTranslate(oid string) (mibName string, oidNum string, oidText string, conversion string, err error) {
+	var out []byte
+	if strings.ContainsAny(oid, ":abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ") {
+		out, err = execCmd("snmptranslate", "-Td", "-Ob", oid)
+	} else {
+		out, err = execCmd("snmptranslate", "-Td", "-Ob", "-m", "all", oid)
+	}
+	if err != nil {
+		return "", "", "", "", err
 	}
 
-	if *name == "" {
-		out, err := execCmd("snmptranslate", "-m", "all", *oid)
+	bb := bytes.NewBuffer(out)
+
+	oidText, err = bb.ReadString('\n')
+	if err != nil {
+		return "", "", "", "", Errorf(err, "getting OID text")
+	}
+	oidText = oidText[:len(oidText)-1]
+
+	i := strings.Index(oidText, "::")
+	if i == -1 {
+		// was not found in MIB. Value is numeric
+		return "", oidText, oidText, "", nil
+	}
+	mibName = oidText[:i]
+	oidText = oidText[i+2:]
+
+	if i := bytes.Index(bb.Bytes(), []byte("  -- TEXTUAL CONVENTION ")); i != -1 {
+		bb.Next(i + len("  -- TEXTUAL CONVENTION "))
+		tc, err := bb.ReadString('\n')
 		if err != nil {
-			//TODO debug message
-			*name = *oid
+			return "", "", "", "", Errorf(err, "getting textual convention")
+		}
+		tc = tc[:len(tc)-1]
+		switch tc {
+		case "MacAddress", "PhysAddress":
+			conversion = "hwaddr"
+		case "InetAddressIPv4", "InetAddressIPv6", "InetAddress":
+			conversion = "ipaddr"
+		}
+	}
+
+	i = bytes.Index(bb.Bytes(), []byte("::= { "))
+	bb.Next(i + len("::= { "))
+	objs, err := bb.ReadString('}')
+	if err != nil {
+		return "", "", "", "", Errorf(err, "getting numeric oid")
+	}
+	objs = objs[:len(objs)-1]
+	for _, obj := range strings.Split(objs, " ") {
+		if len(obj) == 0 {
+			continue
+		}
+		if i := strings.Index(obj, "("); i != -1 {
+			obj = obj[i+1:]
+			oidNum += "." + obj[:strings.Index(obj, ")")]
 		} else {
-			if i := bytes.Index(out, []byte("::")); i != -1 {
-				if mibPrefix != nil {
-					*mibPrefix = string(out[:i+2])
-				}
-				out = out[i+2:]
-			}
-			*name = string(bytes.TrimSuffix(out, []byte{'\n'}))
+			oidNum += "." + obj
 		}
 	}
 
-	return nil
+	return mibName, oidNum, oidText, conversion, nil
 }

plugins/inputs/snmp/snmp_mocks_generate.go

@@ -0,0 +1,97 @@
+// +build generate
+
+package main
+
+import (
+	"bufio"
+	"bytes"
+	"fmt"
+	"os"
+	"os/exec"
+	"strings"
+)
+
+// This file is a generator used to generate the mocks for the commands used by the tests.
+
+// These are the commands to be mocked.
+var mockedCommands = [][]string{
+	{"snmptranslate", "-Td", "-Ob", "-m", "all", ".1.0.0.0"},
+	{"snmptranslate", "-Td", "-Ob", "-m", "all", ".1.0.0.1.1"},
+	{"snmptranslate", "-Td", "-Ob", "-m", "all", ".1.0.0.1.2"},
+	{"snmptranslate", "-Td", "-Ob", "-m", "all", "1.0.0.1.1"},
+	{"snmptranslate", "-Td", "-Ob", "-m", "all", ".1.0.0.0.1.1"},
+	{"snmptranslate", "-Td", "-Ob", "-m", "all", ".1.0.0.0.1.1.0"},
+	{"snmptranslate", "-Td", "-Ob", "-m", "all", ".999"},
+	{"snmptranslate", "-Td", "-Ob", "TEST::server"},
+	{"snmptranslate", "-Td", "-Ob", "TEST::server.0"},
+	{"snmptranslate", "-Td", "-Ob", "TEST::testTable"},
+	{"snmptranslate", "-Td", "-Ob", "TEST::connections"},
+	{"snmptranslate", "-Td", "-Ob", "TEST::latency"},
+	{"snmptranslate", "-Td", "-Ob", "TEST::hostname"},
+	{"snmptranslate", "-Td", "-Ob", "IF-MIB::ifPhysAddress.1"},
+	{"snmptranslate", "-Td", "-Ob", "BRIDGE-MIB::dot1dTpFdbAddress.1"},
+	{"snmptranslate", "-Td", "-Ob", "TCP-MIB::tcpConnectionLocalAddress.1"},
+	{"snmptranslate", "-Td", "TEST::testTable.1"},
+	{"snmptable", "-Ch", "-Cl", "-c", "public", "127.0.0.1", "TEST::testTable"},
+}
+
+type mockedCommandResult struct {
+	stdout    string
+	stderr    string
+	exitError bool
+}
+
+func main() {
+	if err := generate(); err != nil {
+		fmt.Fprintf(os.Stderr, "error: %s\n", err)
+		os.Exit(1)
+	}
+}
+
+func generate() error {
+	f, err := os.OpenFile("snmp_mocks_test.go", os.O_RDWR, 0644)
+	if err != nil {
+		return err
+	}
+	br := bufio.NewReader(f)
+	var i int64
+	for l, err := br.ReadString('\n'); err == nil; l, err = br.ReadString('\n') {
+		i += int64(len(l))
+		if l == "// BEGIN GO GENERATE CONTENT\n" {
+			break
+		}
+	}
+	f.Truncate(i)
+	f.Seek(i, 0)
+
+	fmt.Fprintf(f, "var mockedCommandResults = map[string]mockedCommandResult{\n")
+
+	for _, cmd := range mockedCommands {
+		ec := exec.Command(cmd[0], cmd[1:]...)
+		out := bytes.NewBuffer(nil)
+		err := bytes.NewBuffer(nil)
+		ec.Stdout = out
+		ec.Stderr = err
+		ec.Env = []string{
+			"MIBDIRS=+./testdata",
+		}
+
+		var mcr mockedCommandResult
+		if err := ec.Run(); err != nil {
+			if err, ok := err.(*exec.ExitError); !ok {
+				mcr.exitError = true
+			} else {
+				return fmt.Errorf("executing %v: %s", cmd, err)
+			}
+		}
+		mcr.stdout = string(out.Bytes())
+		mcr.stderr = string(err.Bytes())
+		cmd0 := strings.Join(cmd, "\000")
+		mcrv := fmt.Sprintf("%#v", mcr)[5:] // trim `main.` prefix
+		fmt.Fprintf(f, "%#v: %s,\n", cmd0, mcrv)
+	}
+	f.Write([]byte("}\n"))
+	f.Close()
+
+	return exec.Command("gofmt", "-w", "snmp_mocks_test.go").Run()
+}

plugins/inputs/snmp/snmp_mocks_test.go

@@ -0,0 +1,82 @@
+package snmp
+
+import (
+	"fmt"
+	"os"
+	"os/exec"
+	"strings"
+	"testing"
+)
+
+type mockedCommandResult struct {
+	stdout    string
+	stderr    string
+	exitError bool
+}
+
+func mockExecCommand(arg0 string, args ...string) *exec.Cmd {
+	args = append([]string{"-test.run=TestMockExecCommand", "--", arg0}, args...)
+	cmd := exec.Command(os.Args[0], args...)
+	cmd.Stderr = os.Stderr // so the test output shows errors
+	return cmd
+}
+
+// This is not a real test. This is just a way of mocking out commands.
+//
+// Idea based on https://github.com/golang/go/blob/7c31043/src/os/exec/exec_test.go#L568
+func TestMockExecCommand(t *testing.T) {
+	var cmd []string
+	for _, arg := range os.Args {
+		if string(arg) == "--" {
+			cmd = []string{}
+			continue
+		}
+		if cmd == nil {
+			continue
+		}
+		cmd = append(cmd, string(arg))
+	}
+	if cmd == nil {
+		return
+	}
+
+	cmd0 := strings.Join(cmd, "\000")
+	mcr, ok := mockedCommandResults[cmd0]
+	if !ok {
+		cv := fmt.Sprintf("%#v", cmd)[8:] // trim `[]string` prefix
+		fmt.Fprintf(os.Stderr, "Unmocked command. Please add the following to `mockedCommands` in snmp_mocks_generate.go, and then run `go generate`:\n\t%s,\n", cv)
+		os.Exit(1)
+	}
+	fmt.Printf("%s", mcr.stdout)
+	fmt.Fprintf(os.Stderr, "%s", mcr.stderr)
+	if mcr.exitError {
+		os.Exit(1)
+	}
+	os.Exit(0)
+}
+
+func init() {
+	execCommand = mockExecCommand
+}
+
+// BEGIN GO GENERATE CONTENT
+var mockedCommandResults = map[string]mockedCommandResult{
+	"snmptranslate\x00-Td\x00-Ob\x00-m\x00all\x00.1.0.0.0":                    mockedCommandResult{stdout: "TEST::testTable\ntestTable OBJECT-TYPE\n  -- FROM\tTEST\n  MAX-ACCESS\tnot-accessible\n  STATUS\tcurrent\n::= { iso(1) 0 testOID(0) 0 }\n", stderr: "", exitError: false},
+	"snmptranslate\x00-Td\x00-Ob\x00-m\x00all\x00.1.0.0.1.1":                  mockedCommandResult{stdout: "TEST::hostname\nhostname OBJECT-TYPE\n  -- FROM\tTEST\n  SYNTAX\tOCTET STRING\n  MAX-ACCESS\tread-only\n  STATUS\tcurrent\n::= { iso(1) 0 testOID(0) 1 1 }\n", stderr: "", exitError: false},
+	"snmptranslate\x00-Td\x00-Ob\x00-m\x00all\x00.1.0.0.1.2":                  mockedCommandResult{stdout: "TEST::1.2\nanonymous#1 OBJECT-TYPE\n  -- FROM\tTEST\n::= { iso(1) 0 testOID(0) 1 2 }\n", stderr: "", exitError: false},
+	"snmptranslate\x00-Td\x00-Ob\x00-m\x00all\x001.0.0.1.1":                   mockedCommandResult{stdout: "TEST::hostname\nhostname OBJECT-TYPE\n  -- FROM\tTEST\n  SYNTAX\tOCTET STRING\n  MAX-ACCESS\tread-only\n  STATUS\tcurrent\n::= { iso(1) 0 testOID(0) 1 1 }\n", stderr: "", exitError: false},
+	"snmptranslate\x00-Td\x00-Ob\x00-m\x00all\x00.1.0.0.0.1.1":                mockedCommandResult{stdout: "TEST::server\nserver OBJECT-TYPE\n  -- FROM\tTEST\n  SYNTAX\tOCTET STRING\n  MAX-ACCESS\tread-only\n  STATUS\tcurrent\n::= { iso(1) 0 testOID(0) testTable(0) testTableEntry(1) 1 }\n", stderr: "", exitError: false},
+	"snmptranslate\x00-Td\x00-Ob\x00-m\x00all\x00.1.0.0.0.1.1.0":              mockedCommandResult{stdout: "TEST::server.0\nserver OBJECT-TYPE\n  -- FROM\tTEST\n  SYNTAX\tOCTET STRING\n  MAX-ACCESS\tread-only\n  STATUS\tcurrent\n::= { iso(1) 0 testOID(0) testTable(0) testTableEntry(1) server(1) 0 }\n", stderr: "", exitError: false},
+	"snmptranslate\x00-Td\x00-Ob\x00-m\x00all\x00.999":                        mockedCommandResult{stdout: ".999\n [TRUNCATED]\n", stderr: "", exitError: false},
+	"snmptranslate\x00-Td\x00-Ob\x00TEST::server":                             mockedCommandResult{stdout: "TEST::server\nserver OBJECT-TYPE\n  -- FROM\tTEST\n  SYNTAX\tOCTET STRING\n  MAX-ACCESS\tread-only\n  STATUS\tcurrent\n::= { iso(1) 0 testOID(0) testTable(0) testTableEntry(1) 1 }\n", stderr: "", exitError: false},
+	"snmptranslate\x00-Td\x00-Ob\x00TEST::server.0":                           mockedCommandResult{stdout: "TEST::server.0\nserver OBJECT-TYPE\n  -- FROM\tTEST\n  SYNTAX\tOCTET STRING\n  MAX-ACCESS\tread-only\n  STATUS\tcurrent\n::= { iso(1) 0 testOID(0) testTable(0) testTableEntry(1) server(1) 0 }\n", stderr: "", exitError: false},
+	"snmptranslate\x00-Td\x00-Ob\x00TEST::testTable":                          mockedCommandResult{stdout: "TEST::testTable\ntestTable OBJECT-TYPE\n  -- FROM\tTEST\n  MAX-ACCESS\tnot-accessible\n  STATUS\tcurrent\n::= { iso(1) 0 testOID(0) 0 }\n", stderr: "", exitError: false},
+	"snmptranslate\x00-Td\x00-Ob\x00TEST::connections":                        mockedCommandResult{stdout: "TEST::connections\nconnections OBJECT-TYPE\n  -- FROM\tTEST\n  SYNTAX\tINTEGER\n  MAX-ACCESS\tread-only\n  STATUS\tcurrent\n::= { iso(1) 0 testOID(0) testTable(0) testTableEntry(1) 2 }\n", stderr: "", exitError: false},
+	"snmptranslate\x00-Td\x00-Ob\x00TEST::latency":                            mockedCommandResult{stdout: "TEST::latency\nlatency OBJECT-TYPE\n  -- FROM\tTEST\n  SYNTAX\tOCTET STRING\n  MAX-ACCESS\tread-only\n  STATUS\tcurrent\n::= { iso(1) 0 testOID(0) testTable(0) testTableEntry(1) 3 }\n", stderr: "", exitError: false},
+	"snmptranslate\x00-Td\x00-Ob\x00TEST::hostname":                           mockedCommandResult{stdout: "TEST::hostname\nhostname OBJECT-TYPE\n  -- FROM\tTEST\n  SYNTAX\tOCTET STRING\n  MAX-ACCESS\tread-only\n  STATUS\tcurrent\n::= { iso(1) 0 testOID(0) 1 1 }\n", stderr: "", exitError: false},
+	"snmptranslate\x00-Td\x00-Ob\x00IF-MIB::ifPhysAddress.1":                  mockedCommandResult{stdout: "IF-MIB::ifPhysAddress.1\nifPhysAddress OBJECT-TYPE\n  -- FROM\tIF-MIB\n  -- TEXTUAL CONVENTION PhysAddress\n  SYNTAX\tOCTET STRING\n  DISPLAY-HINT\t\"1x:\"\n  MAX-ACCESS\tread-only\n  STATUS\tcurrent\n  DESCRIPTION\t\"The interface's address at its protocol sub-layer.  For\n            example, for an 802.x interface, this object normally\n            contains a MAC address.  The interface's media-specific MIB\n            must define the bit and byte ordering and the format of the\n            value of this object.  For interfaces which do not have such\n            an address (e.g., a serial line), this object should contain\n            an octet string of zero length.\"\n::= { iso(1) org(3) dod(6) internet(1) mgmt(2) mib-2(1) interfaces(2) ifTable(2) ifEntry(1) ifPhysAddress(6) 1 }\n", stderr: "", exitError: false},
+	"snmptranslate\x00-Td\x00-Ob\x00BRIDGE-MIB::dot1dTpFdbAddress.1":          mockedCommandResult{stdout: "BRIDGE-MIB::dot1dTpFdbAddress.1\ndot1dTpFdbAddress OBJECT-TYPE\n  -- FROM\tBRIDGE-MIB\n  -- TEXTUAL CONVENTION MacAddress\n  SYNTAX\tOCTET STRING (6) \n  DISPLAY-HINT\t\"1x:\"\n  MAX-ACCESS\tread-only\n  STATUS\tcurrent\n  DESCRIPTION\t\"A unicast MAC address for which the bridge has\n        forwarding and/or filtering information.\"\n::= { iso(1) org(3) dod(6) internet(1) mgmt(2) mib-2(1) dot1dBridge(17) dot1dTp(4) dot1dTpFdbTable(3) dot1dTpFdbEntry(1) dot1dTpFdbAddress(1) 1 }\n", stderr: "", exitError: false},
+	"snmptranslate\x00-Td\x00-Ob\x00TCP-MIB::tcpConnectionLocalAddress.1":     mockedCommandResult{stdout: "TCP-MIB::tcpConnectionLocalAddress.1\ntcpConnectionLocalAddress OBJECT-TYPE\n  -- FROM\tTCP-MIB\n  -- TEXTUAL CONVENTION InetAddress\n  SYNTAX\tOCTET STRING (0..255) \n  MAX-ACCESS\tnot-accessible\n  STATUS\tcurrent\n  DESCRIPTION\t\"The local IP address for this TCP connection.  The type\n            of this address is determined by the value of\n            tcpConnectionLocalAddressType.\n\n            As this object is used in the index for the\n            tcpConnectionTable, implementors should be\n            careful not to create entries that would result in OIDs\n            with more than 128 subidentifiers; otherwise the information\n            cannot be accessed by using SNMPv1, SNMPv2c, or SNMPv3.\"\n::= { iso(1) org(3) dod(6) internet(1) mgmt(2) mib-2(1) tcp(6) tcpConnectionTable(19) tcpConnectionEntry(1) tcpConnectionLocalAddress(2) 1 }\n", stderr: "", exitError: false},
+	"snmptranslate\x00-Td\x00TEST::testTable.1":                               mockedCommandResult{stdout: "TEST::testTableEntry\ntestTableEntry OBJECT-TYPE\n  -- FROM\tTEST\n  MAX-ACCESS\tnot-accessible\n  STATUS\tcurrent\n  INDEX\t\t{ server }\n::= { iso(1) 0 testOID(0) testTable(0) 1 }\n", stderr: "", exitError: false},
+	"snmptable\x00-Ch\x00-Cl\x00-c\x00public\x00127.0.0.1\x00TEST::testTable": mockedCommandResult{stdout: "server connections latency \nTEST::testTable: No entries\n", stderr: "", exitError: false},
+}

plugins/inputs/snmp/snmp_test.go

@@ -1,11 +1,9 @@
+//go:generate go run -tags generate snmp_mocks_generate.go
 package snmp
 
 import (
 	"fmt"
 	"net"
-	"os"
-	"os/exec"
-	"strings"
 	"sync"
 	"testing"
 	"time"
@@ -18,77 +16,6 @@ import (
 	"github.com/stretchr/testify/require"
 )
 
-func mockExecCommand(arg0 string, args ...string) *exec.Cmd {
-	args = append([]string{"-test.run=TestMockExecCommand", "--", arg0}, args...)
-	cmd := exec.Command(os.Args[0], args...)
-	cmd.Stderr = os.Stderr // so the test output shows errors
-	return cmd
-}
-func TestMockExecCommand(t *testing.T) {
-	var cmd []string
-	for _, arg := range os.Args {
-		if string(arg) == "--" {
-			cmd = []string{}
-			continue
-		}
-		if cmd == nil {
-			continue
-		}
-		cmd = append(cmd, string(arg))
-	}
-	if cmd == nil {
-		return
-	}
-
-	// will not properly handle args with spaces, but it's good enough
-	cmdStr := strings.Join(cmd, " ")
-	switch cmdStr {
-	case "snmptranslate -m all .1.0.0.0":
-		fmt.Printf("TEST::testTable\n")
-	case "snmptranslate -m all .1.0.0.0.1.1":
-		fmt.Printf("server\n")
-	case "snmptranslate -m all .1.0.0.0.1.1.0":
-		fmt.Printf("server.0\n")
-	case "snmptranslate -m all .1.0.0.1.1":
-		fmt.Printf("hostname\n")
-	case "snmptranslate -m all .999":
-		fmt.Printf(".999\n")
-	case "snmptranslate -m all -On TEST::testTable":
-		fmt.Printf(".1.0.0.0\n")
-	case "snmptranslate -m all -On TEST::hostname":
-		fmt.Printf(".1.0.0.1.1\n")
-	case "snmptranslate -m all -On TEST::server":
-		fmt.Printf(".1.0.0.0.1.1\n")
-	case "snmptranslate -m all -On TEST::connections":
-		fmt.Printf(".1.0.0.0.1.2\n")
-	case "snmptranslate -m all -On TEST::latency":
-		fmt.Printf(".1.0.0.0.1.3\n")
-	case "snmptranslate -m all -On TEST::server.0":
-		fmt.Printf(".1.0.0.0.1.1.0\n")
-	case "snmptranslate -m all -Td .1.0.0.0.1":
-		fmt.Printf(`TEST::testTableEntry
-testTableEntry OBJECT-TYPE
-  -- FROM	TEST
-  MAX-ACCESS	not-accessible
-  STATUS	current
-  INDEX		{ server }
-::= { iso(1) 2 testOID(3) testTable(0) 1 }
-`)
-	case "snmptable -m all -Ch -Cl -c public 127.0.0.1 .1.0.0.0":
-		fmt.Printf(`server connections latency 
-TEST::testTable: No entries
-`)
-	default:
-		fmt.Fprintf(os.Stderr, "Command not mocked: `%s`\n", cmdStr)
-		// you get the expected output by running the missing command with `-M testdata` in the plugin directory.
-		os.Exit(1)
-	}
-	os.Exit(0)
-}
-func init() {
-	execCommand = mockExecCommand
-}
-
 type testSNMPConnection struct {
 	host   string
 	values map[string]interface{}
@@ -133,18 +60,20 @@ func (tsc *testSNMPConnection) Walk(oid string, wf gosnmp.WalkFunc) error {
 var tsc = &testSNMPConnection{
 	host: "tsc",
 	values: map[string]interface{}{
-		".1.0.0.0.1.1.0": "foo",
-		".1.0.0.0.1.1.1": []byte("bar"),
-		".1.0.0.0.1.102": "bad",
-		".1.0.0.0.1.2.0": 1,
-		".1.0.0.0.1.2.1": 2,
-		".1.0.0.0.1.3.0": "0.123",
-		".1.0.0.0.1.3.1": "0.456",
-		".1.0.0.0.1.3.2": "9.999",
-		".1.0.0.0.1.4.0": 123456,
-		".1.0.0.1.1":     "baz",
-		".1.0.0.1.2":     234,
-		".1.0.0.1.3":     []byte("byte slice"),
+		".1.0.0.0.1.1.0":     "foo",
+		".1.0.0.0.1.1.1":     []byte("bar"),
+		".1.0.0.0.1.102":     "bad",
+		".1.0.0.0.1.2.0":     1,
+		".1.0.0.0.1.2.1":     2,
+		".1.0.0.0.1.3.0":     "0.123",
+		".1.0.0.0.1.3.1":     "0.456",
+		".1.0.0.0.1.3.2":     "9.999",
+		".1.0.0.0.1.4.0":     123456,
+		".1.0.0.1.1":         "baz",
+		".1.0.0.1.2":         234,
+		".1.0.0.1.3":         []byte("byte slice"),
+		".1.0.0.2.1.5.0.9.9": 11,
+		".1.0.0.2.1.5.1.9.9": 22,
 	},
 }
 
@@ -162,7 +91,8 @@ func TestSampleConfig(t *testing.T) {
 		Timeout:        internal.Duration{Duration: 5 * time.Second},
 		Version:        2,
 		Community:      "public",
-		MaxRepetitions: 50,
+		MaxRepetitions: 10,
+		Retries:        3,
 
 		Name: "system",
 		Fields: []Field{
@@ -191,27 +121,33 @@ func TestSampleConfig(t *testing.T) {
 
 func TestFieldInit(t *testing.T) {
 	translations := []struct {
-		inputOid     string
-		inputName    string
-		expectedOid  string
-		expectedName string
+		inputOid           string
+		inputName          string
+		inputConversion    string
+		expectedOid        string
+		expectedName       string
+		expectedConversion string
 	}{
-		{".1.0.0.0.1.1", "", ".1.0.0.0.1.1", "server"},
-		{".1.0.0.0.1.1.0", "", ".1.0.0.0.1.1.0", "server.0"},
-		{".999", "", ".999", ".999"},
-		{"TEST::server", "", ".1.0.0.0.1.1", "server"},
-		{"TEST::server.0", "", ".1.0.0.0.1.1.0", "server.0"},
-		{"TEST::server", "foo", ".1.0.0.0.1.1", "foo"},
+		{".1.0.0.0.1.1", "", "", ".1.0.0.0.1.1", "server", ""},
+		{".1.0.0.0.1.1.0", "", "", ".1.0.0.0.1.1.0", "server.0", ""},
+		{".999", "", "", ".999", ".999", ""},
+		{"TEST::server", "", "", ".1.0.0.0.1.1", "server", ""},
+		{"TEST::server.0", "", "", ".1.0.0.0.1.1.0", "server.0", ""},
+		{"TEST::server", "foo", "", ".1.0.0.0.1.1", "foo", ""},
+		{"IF-MIB::ifPhysAddress.1", "", "", ".1.3.6.1.2.1.2.2.1.6.1", "ifPhysAddress.1", "hwaddr"},
+		{"IF-MIB::ifPhysAddress.1", "", "none", ".1.3.6.1.2.1.2.2.1.6.1", "ifPhysAddress.1", "none"},
+		{"BRIDGE-MIB::dot1dTpFdbAddress.1", "", "", ".1.3.6.1.2.1.17.4.3.1.1.1", "dot1dTpFdbAddress.1", "hwaddr"},
+		{"TCP-MIB::tcpConnectionLocalAddress.1", "", "", ".1.3.6.1.2.1.6.19.1.2.1", "tcpConnectionLocalAddress.1", "ipaddr"},
 	}
 
 	for _, txl := range translations {
-		f := Field{Oid: txl.inputOid, Name: txl.inputName}
+		f := Field{Oid: txl.inputOid, Name: txl.inputName, Conversion: txl.inputConversion}
 		err := f.init()
 		if !assert.NoError(t, err, "inputOid='%s' inputName='%s'", txl.inputOid, txl.inputName) {
 			continue
 		}
-		assert.Equal(t, txl.expectedOid, f.Oid, "inputOid='%s' inputName='%s'", txl.inputOid, txl.inputName)
-		assert.Equal(t, txl.expectedName, f.Name, "inputOid='%s' inputName='%s'", txl.inputOid, txl.inputName)
+		assert.Equal(t, txl.expectedOid, f.Oid, "inputOid='%s' inputName='%s' inputConversion='%s'", txl.inputOid, txl.inputName, txl.inputConversion)
+		assert.Equal(t, txl.expectedName, f.Name, "inputOid='%s' inputName='%s' inputConversion='%s'", txl.inputOid, txl.inputName, txl.inputConversion)
 	}
 }
 
@@ -302,7 +238,7 @@ func TestGetSNMPConnection_v3(t *testing.T) {
 	assert.Equal(t, gs.Version, gosnmp.Version3)
 	sp := gs.SecurityParameters.(*gosnmp.UsmSecurityParameters)
 	assert.Equal(t, "1.2.3.4", gsc.Host())
-	assert.Equal(t, 20, gs.MaxRepetitions)
+	assert.EqualValues(t, 20, gs.MaxRepetitions)
 	assert.Equal(t, "mycontext", gs.ContextName)
 	assert.Equal(t, gosnmp.AuthPriv, gs.MsgFlags&gosnmp.AuthPriv)
 	assert.Equal(t, "myuser", sp.UserName)
@@ -437,6 +373,11 @@ func TestTableBuild_walk(t *testing.T) {
 				Oid:        ".1.0.0.0.1.3",
 				Conversion: "float",
 			},
+			{
+				Name:           "myfield4",
+				Oid:            ".1.0.0.2.1.5",
+				OidIndexSuffix: ".9.9",
+			},
 		},
 	}
 
@@ -445,12 +386,20 @@ func TestTableBuild_walk(t *testing.T) {
 
 	assert.Equal(t, tb.Name, "mytable")
 	rtr1 := RTableRow{
-		Tags:   map[string]string{"myfield1": "foo"},
-		Fields: map[string]interface{}{"myfield2": 1, "myfield3": float64(0.123)},
+		Tags: map[string]string{"myfield1": "foo"},
+		Fields: map[string]interface{}{
+			"myfield2": 1,
+			"myfield3": float64(0.123),
+			"myfield4": 11,
+		},
 	}
 	rtr2 := RTableRow{
-		Tags:   map[string]string{"myfield1": "bar"},
-		Fields: map[string]interface{}{"myfield2": 2, "myfield3": float64(0.456)},
+		Tags: map[string]string{"myfield1": "bar"},
+		Fields: map[string]interface{}{
+			"myfield2": 2,
+			"myfield3": float64(0.456),
+			"myfield4": 22,
+		},
 	}
 	assert.Len(t, tb.Rows, 2)
 	assert.Contains(t, tb.Rows, rtr1)
@@ -619,10 +568,18 @@ func TestFieldConvert(t *testing.T) {
 		{uint16(123), "int", int64(123)},
 		{uint32(123), "int", int64(123)},
 		{uint64(123), "int", int64(123)},
+		{[]byte("abcdef"), "hwaddr", "61:62:63:64:65:66"},
+		{"abcdef", "hwaddr", "61:62:63:64:65:66"},
+		{[]byte("abcd"), "ipaddr", "97.98.99.100"},
+		{"abcd", "ipaddr", "97.98.99.100"},
+		{[]byte("abcdefghijklmnop"), "ipaddr", "6162:6364:6566:6768:696a:6b6c:6d6e:6f70"},
 	}
 
 	for _, tc := range testTable {
-		act := fieldConvert(tc.conv, tc.input)
+		act, err := fieldConvert(tc.conv, tc.input)
+		if !assert.NoError(t, err, "input=%T(%v) conv=%s expected=%T(%v)", tc.input, tc.input, tc.conv, tc.expected, tc.expected) {
+			continue
+		}
 		assert.EqualValues(t, tc.expected, act, "input=%T(%v) conv=%s expected=%T(%v)", tc.input, tc.input, tc.conv, tc.expected, tc.expected)
 	}
 }

plugins/inputs/snmp_legacy/snmp_legacy.go

@@ -296,7 +296,7 @@ func (s *Snmp) Gather(acc telegraf.Accumulator) error {
 
 		data, err := ioutil.ReadFile(s.SnmptranslateFile)
 		if err != nil {
-			log.Printf("Reading SNMPtranslate file error: %s", err)
+			log.Printf("E! Reading SNMPtranslate file error: %s", err)
 			return err
 		} else {
 			for _, line := range strings.Split(string(data), "\n") {
@@ -394,16 +394,16 @@ func (s *Snmp) Gather(acc telegraf.Accumulator) error {
 		// only if len(s.OidInstanceMapping) == 0
 		if len(host.OidInstanceMapping) >= 0 {
 			if err := host.SNMPMap(acc, s.nameToOid, s.subTableMap); err != nil {
-				log.Printf("SNMP Mapping error for host '%s': %s", host.Address, err)
+				log.Printf("E! SNMP Mapping error for host '%s': %s", host.Address, err)
 				continue
 			}
 		}
 		// Launch Get requests
 		if err := host.SNMPGet(acc, s.initNode); err != nil {
-			log.Printf("SNMP Error for host '%s': %s", host.Address, err)
+			log.Printf("E! SNMP Error for host '%s': %s", host.Address, err)
 		}
 		if err := host.SNMPBulk(acc, s.initNode); err != nil {
-			log.Printf("SNMP Error for host '%s': %s", host.Address, err)
+			log.Printf("E! SNMP Error for host '%s': %s", host.Address, err)
 		}
 	}
 	return nil
@@ -800,7 +800,7 @@ func (h *Host) HandleResponse(
 					acc.AddFields(field_name, fields, tags)
 				case gosnmp.NoSuchObject, gosnmp.NoSuchInstance:
 					// Oid not found
-					log.Printf("[snmp input] Oid not found: %s", oid_key)
+					log.Printf("E! [snmp input] Oid not found: %s", oid_key)
 				default:
 					// delete other data
 				}

plugins/inputs/snmp_legacy/snmp_legacy_test.go

@@ -1,482 +0,0 @@
-package snmp_legacy
-
-import (
-	"testing"
-
-	"github.com/influxdata/telegraf/testutil"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-)
-
-func TestSNMPErrorGet1(t *testing.T) {
-	get1 := Data{
-		Name: "oid1",
-		Unit: "octets",
-		Oid:  ".1.3.6.1.2.1.2.2.1.16.1",
-	}
-	h := Host{
-		Collect: []string{"oid1"},
-	}
-	s := Snmp{
-		SnmptranslateFile: "bad_oid.txt",
-		Host:              []Host{h},
-		Get:               []Data{get1},
-	}
-
-	var acc testutil.Accumulator
-	err := s.Gather(&acc)
-	require.Error(t, err)
-}
-
-func TestSNMPErrorGet2(t *testing.T) {
-	get1 := Data{
-		Name: "oid1",
-		Unit: "octets",
-		Oid:  ".1.3.6.1.2.1.2.2.1.16.1",
-	}
-	h := Host{
-		Collect: []string{"oid1"},
-	}
-	s := Snmp{
-		Host: []Host{h},
-		Get:  []Data{get1},
-	}
-
-	var acc testutil.Accumulator
-	err := s.Gather(&acc)
-	require.NoError(t, err)
-	assert.Equal(t, 0, len(acc.Metrics))
-}
-
-func TestSNMPErrorBulk(t *testing.T) {
-	bulk1 := Data{
-		Name: "oid1",
-		Unit: "octets",
-		Oid:  ".1.3.6.1.2.1.2.2.1.16",
-	}
-	h := Host{
-		Address: testutil.GetLocalHost(),
-		Collect: []string{"oid1"},
-	}
-	s := Snmp{
-		Host: []Host{h},
-		Bulk: []Data{bulk1},
-	}
-
-	var acc testutil.Accumulator
-	err := s.Gather(&acc)
-	require.NoError(t, err)
-	assert.Equal(t, 0, len(acc.Metrics))
-}
-
-func TestSNMPGet1(t *testing.T) {
-	if testing.Short() {
-		t.Skip("Skipping integration test in short mode")
-	}
-	get1 := Data{
-		Name: "oid1",
-		Unit: "octets",
-		Oid:  ".1.3.6.1.2.1.2.2.1.16.1",
-	}
-	h := Host{
-		Address:   testutil.GetLocalHost() + ":31161",
-		Community: "telegraf",
-		Version:   2,
-		Timeout:   2.0,
-		Retries:   2,
-		Collect:   []string{"oid1"},
-	}
-	s := Snmp{
-		Host: []Host{h},
-		Get:  []Data{get1},
-	}
-
-	var acc testutil.Accumulator
-	err := s.Gather(&acc)
-	require.NoError(t, err)
-
-	acc.AssertContainsTaggedFields(t,
-		"oid1",
-		map[string]interface{}{
-			"oid1": uint(543846),
-		},
-		map[string]string{
-			"unit":      "octets",
-			"snmp_host": testutil.GetLocalHost(),
-		},
-	)
-}
-
-func TestSNMPGet2(t *testing.T) {
-	if testing.Short() {
-		t.Skip("Skipping integration test in short mode")
-	}
-	get1 := Data{
-		Name: "oid1",
-		Oid:  "ifNumber",
-	}
-	h := Host{
-		Address:   testutil.GetLocalHost() + ":31161",
-		Community: "telegraf",
-		Version:   2,
-		Timeout:   2.0,
-		Retries:   2,
-		Collect:   []string{"oid1"},
-	}
-	s := Snmp{
-		SnmptranslateFile: "./testdata/oids.txt",
-		Host:              []Host{h},
-		Get:               []Data{get1},
-	}
-
-	var acc testutil.Accumulator
-	err := s.Gather(&acc)
-	require.NoError(t, err)
-
-	acc.AssertContainsTaggedFields(t,
-		"ifNumber",
-		map[string]interface{}{
-			"ifNumber": int(4),
-		},
-		map[string]string{
-			"instance":  "0",
-			"snmp_host": testutil.GetLocalHost(),
-		},
-	)
-}
-
-func TestSNMPGet3(t *testing.T) {
-	if testing.Short() {
-		t.Skip("Skipping integration test in short mode")
-	}
-	get1 := Data{
-		Name:     "oid1",
-		Unit:     "octets",
-		Oid:      "ifSpeed",
-		Instance: "1",
-	}
-	h := Host{
-		Address:   testutil.GetLocalHost() + ":31161",
-		Community: "telegraf",
-		Version:   2,
-		Timeout:   2.0,
-		Retries:   2,
-		Collect:   []string{"oid1"},
-	}
-	s := Snmp{
-		SnmptranslateFile: "./testdata/oids.txt",
-		Host:              []Host{h},
-		Get:               []Data{get1},
-	}
-
-	var acc testutil.Accumulator
-	err := s.Gather(&acc)
-	require.NoError(t, err)
-
-	acc.AssertContainsTaggedFields(t,
-		"ifSpeed",
-		map[string]interface{}{
-			"ifSpeed": uint(10000000),
-		},
-		map[string]string{
-			"unit":      "octets",
-			"instance":  "1",
-			"snmp_host": testutil.GetLocalHost(),
-		},
-	)
-}
-
-func TestSNMPEasyGet4(t *testing.T) {
-	if testing.Short() {
-		t.Skip("Skipping integration test in short mode")
-	}
-	get1 := Data{
-		Name:     "oid1",
-		Unit:     "octets",
-		Oid:      "ifSpeed",
-		Instance: "1",
-	}
-	h := Host{
-		Address:   testutil.GetLocalHost() + ":31161",
-		Community: "telegraf",
-		Version:   2,
-		Timeout:   2.0,
-		Retries:   2,
-		Collect:   []string{"oid1"},
-		GetOids:   []string{"ifNumber"},
-	}
-	s := Snmp{
-		SnmptranslateFile: "./testdata/oids.txt",
-		Host:              []Host{h},
-		Get:               []Data{get1},
-	}
-
-	var acc testutil.Accumulator
-	err := s.Gather(&acc)
-	require.NoError(t, err)
-
-	acc.AssertContainsTaggedFields(t,
-		"ifSpeed",
-		map[string]interface{}{
-			"ifSpeed": uint(10000000),
-		},
-		map[string]string{
-			"unit":      "octets",
-			"instance":  "1",
-			"snmp_host": testutil.GetLocalHost(),
-		},
-	)
-
-	acc.AssertContainsTaggedFields(t,
-		"ifNumber",
-		map[string]interface{}{
-			"ifNumber": int(4),
-		},
-		map[string]string{
-			"instance":  "0",
-			"snmp_host": testutil.GetLocalHost(),
-		},
-	)
-}
-
-func TestSNMPEasyGet5(t *testing.T) {
-	if testing.Short() {
-		t.Skip("Skipping integration test in short mode")
-	}
-	get1 := Data{
-		Name:     "oid1",
-		Unit:     "octets",
-		Oid:      "ifSpeed",
-		Instance: "1",
-	}
-	h := Host{
-		Address:   testutil.GetLocalHost() + ":31161",
-		Community: "telegraf",
-		Version:   2,
-		Timeout:   2.0,
-		Retries:   2,
-		Collect:   []string{"oid1"},
-		GetOids:   []string{".1.3.6.1.2.1.2.1.0"},
-	}
-	s := Snmp{
-		SnmptranslateFile: "./testdata/oids.txt",
-		Host:              []Host{h},
-		Get:               []Data{get1},
-	}
-
-	var acc testutil.Accumulator
-	err := s.Gather(&acc)
-	require.NoError(t, err)
-
-	acc.AssertContainsTaggedFields(t,
-		"ifSpeed",
-		map[string]interface{}{
-			"ifSpeed": uint(10000000),
-		},
-		map[string]string{
-			"unit":      "octets",
-			"instance":  "1",
-			"snmp_host": testutil.GetLocalHost(),
-		},
-	)
-
-	acc.AssertContainsTaggedFields(t,
-		"ifNumber",
-		map[string]interface{}{
-			"ifNumber": int(4),
-		},
-		map[string]string{
-			"instance":  "0",
-			"snmp_host": testutil.GetLocalHost(),
-		},
-	)
-}
-
-func TestSNMPEasyGet6(t *testing.T) {
-	if testing.Short() {
-		t.Skip("Skipping integration test in short mode")
-	}
-	h := Host{
-		Address:   testutil.GetLocalHost() + ":31161",
-		Community: "telegraf",
-		Version:   2,
-		Timeout:   2.0,
-		Retries:   2,
-		GetOids:   []string{"1.3.6.1.2.1.2.1.0"},
-	}
-	s := Snmp{
-		SnmptranslateFile: "./testdata/oids.txt",
-		Host:              []Host{h},
-	}
-
-	var acc testutil.Accumulator
-	err := s.Gather(&acc)
-	require.NoError(t, err)
-
-	acc.AssertContainsTaggedFields(t,
-		"ifNumber",
-		map[string]interface{}{
-			"ifNumber": int(4),
-		},
-		map[string]string{
-			"instance":  "0",
-			"snmp_host": testutil.GetLocalHost(),
-		},
-	)
-}
-
-func TestSNMPBulk1(t *testing.T) {
-	if testing.Short() {
-		t.Skip("Skipping integration test in short mode")
-	}
-	bulk1 := Data{
-		Name:          "oid1",
-		Unit:          "octets",
-		Oid:           ".1.3.6.1.2.1.2.2.1.16",
-		MaxRepetition: 2,
-	}
-	h := Host{
-		Address:   testutil.GetLocalHost() + ":31161",
-		Community: "telegraf",
-		Version:   2,
-		Timeout:   2.0,
-		Retries:   2,
-		Collect:   []string{"oid1"},
-	}
-	s := Snmp{
-		SnmptranslateFile: "./testdata/oids.txt",
-		Host:              []Host{h},
-		Bulk:              []Data{bulk1},
-	}
-
-	var acc testutil.Accumulator
-	err := s.Gather(&acc)
-	require.NoError(t, err)
-
-	acc.AssertContainsTaggedFields(t,
-		"ifOutOctets",
-		map[string]interface{}{
-			"ifOutOctets": uint(543846),
-		},
-		map[string]string{
-			"unit":      "octets",
-			"instance":  "1",
-			"snmp_host": testutil.GetLocalHost(),
-		},
-	)
-
-	acc.AssertContainsTaggedFields(t,
-		"ifOutOctets",
-		map[string]interface{}{
-			"ifOutOctets": uint(26475179),
-		},
-		map[string]string{
-			"unit":      "octets",
-			"instance":  "2",
-			"snmp_host": testutil.GetLocalHost(),
-		},
-	)
-
-	acc.AssertContainsTaggedFields(t,
-		"ifOutOctets",
-		map[string]interface{}{
-			"ifOutOctets": uint(108963968),
-		},
-		map[string]string{
-			"unit":      "octets",
-			"instance":  "3",
-			"snmp_host": testutil.GetLocalHost(),
-		},
-	)
-
-	acc.AssertContainsTaggedFields(t,
-		"ifOutOctets",
-		map[string]interface{}{
-			"ifOutOctets": uint(12991453),
-		},
-		map[string]string{
-			"unit":      "octets",
-			"instance":  "36",
-			"snmp_host": testutil.GetLocalHost(),
-		},
-	)
-}
-
-// TODO find why, if this test is active
-// Circle CI stops with the following error...
-// bash scripts/circle-test.sh died unexpectedly
-// Maybe the test is too long ??
-func dTestSNMPBulk2(t *testing.T) {
-	bulk1 := Data{
-		Name:          "oid1",
-		Unit:          "octets",
-		Oid:           "ifOutOctets",
-		MaxRepetition: 2,
-	}
-	h := Host{
-		Address:   testutil.GetLocalHost() + ":31161",
-		Community: "telegraf",
-		Version:   2,
-		Timeout:   2.0,
-		Retries:   2,
-		Collect:   []string{"oid1"},
-	}
-	s := Snmp{
-		SnmptranslateFile: "./testdata/oids.txt",
-		Host:              []Host{h},
-		Bulk:              []Data{bulk1},
-	}
-
-	var acc testutil.Accumulator
-	err := s.Gather(&acc)
-	require.NoError(t, err)
-
-	acc.AssertContainsTaggedFields(t,
-		"ifOutOctets",
-		map[string]interface{}{
-			"ifOutOctets": uint(543846),
-		},
-		map[string]string{
-			"unit":      "octets",
-			"instance":  "1",
-			"snmp_host": testutil.GetLocalHost(),
-		},
-	)
-
-	acc.AssertContainsTaggedFields(t,
-		"ifOutOctets",
-		map[string]interface{}{
-			"ifOutOctets": uint(26475179),
-		},
-		map[string]string{
-			"unit":      "octets",
-			"instance":  "2",
-			"snmp_host": testutil.GetLocalHost(),
-		},
-	)
-
-	acc.AssertContainsTaggedFields(t,
-		"ifOutOctets",
-		map[string]interface{}{
-			"ifOutOctets": uint(108963968),
-		},
-		map[string]string{
-			"unit":      "octets",
-			"instance":  "3",
-			"snmp_host": testutil.GetLocalHost(),
-		},
-	)
-
-	acc.AssertContainsTaggedFields(t,
-		"ifOutOctets",
-		map[string]interface{}{
-			"ifOutOctets": uint(12991453),
-		},
-		map[string]string{
-			"unit":      "octets",
-			"instance":  "36",
-			"snmp_host": testutil.GetLocalHost(),
-		},
-	)
-}

plugins/inputs/snmp_legacy/testdata/oids.txt

@@ -1,32 +0,0 @@
-org			1.3
-dod			1.3.6
-internet			1.3.6.1
-directory			1.3.6.1.1
-mgmt			1.3.6.1.2
-mib-2			1.3.6.1.2.1
-interfaces			1.3.6.1.2.1.2
-ifNumber			1.3.6.1.2.1.2.1
-ifTable			1.3.6.1.2.1.2.2
-ifEntry			1.3.6.1.2.1.2.2.1
-ifIndex			1.3.6.1.2.1.2.2.1.1
-ifDescr			1.3.6.1.2.1.2.2.1.2
-ifType			1.3.6.1.2.1.2.2.1.3
-ifMtu			1.3.6.1.2.1.2.2.1.4
-ifSpeed			1.3.6.1.2.1.2.2.1.5
-ifPhysAddress			1.3.6.1.2.1.2.2.1.6
-ifAdminStatus			1.3.6.1.2.1.2.2.1.7
-ifOperStatus			1.3.6.1.2.1.2.2.1.8
-ifLastChange			1.3.6.1.2.1.2.2.1.9
-ifInOctets			1.3.6.1.2.1.2.2.1.10
-ifInUcastPkts			1.3.6.1.2.1.2.2.1.11
-ifInNUcastPkts			1.3.6.1.2.1.2.2.1.12
-ifInDiscards			1.3.6.1.2.1.2.2.1.13
-ifInErrors			1.3.6.1.2.1.2.2.1.14
-ifInUnknownProtos			1.3.6.1.2.1.2.2.1.15
-ifOutOctets			1.3.6.1.2.1.2.2.1.16
-ifOutUcastPkts			1.3.6.1.2.1.2.2.1.17
-ifOutNUcastPkts			1.3.6.1.2.1.2.2.1.18
-ifOutDiscards			1.3.6.1.2.1.2.2.1.19
-ifOutErrors			1.3.6.1.2.1.2.2.1.20
-ifOutQLen			1.3.6.1.2.1.2.2.1.21
-ifSpecific			1.3.6.1.2.1.2.2.1.22

plugins/inputs/sqlserver/sqlserver.go

@@ -166,7 +166,9 @@ func (s *SQLServer) accRow(query Query, acc telegraf.Accumulator, row scanner) e
 
 	if query.ResultByRow {
 		// add measurement to Accumulator
-		acc.Add(measurement, *columnMap["value"], tags, time.Now())
+		acc.AddFields(measurement,
+			map[string]interface{}{"value": *columnMap["value"]},
+			tags, time.Now())
 	} else {
 		// values
 		for header, val := range columnMap {
@@ -290,8 +292,8 @@ IF OBJECT_ID('tempdb..#clerk') IS NOT NULL
 	DROP TABLE #clerk;
 
 CREATE TABLE #clerk (
-    ClerkCategory nvarchar(64) NOT NULL, 
-    UsedPercent decimal(9,2), 
+    ClerkCategory nvarchar(64) NOT NULL,
+    UsedPercent decimal(9,2),
     UsedBytes bigint
 );
 
@@ -624,26 +626,22 @@ const sqlDatabaseIO string = `SET NOCOUNT ON;
 SET TRANSACTION ISOLATION LEVEL READ UNCOMMITTED;
 DECLARE @secondsBetween tinyint = 5;
 DECLARE @delayInterval char(8) = CONVERT(Char(8), DATEADD(SECOND, @secondsBetween, '00:00:00'), 108);
-
 IF OBJECT_ID('tempdb..#baseline') IS NOT NULL
 	DROP TABLE #baseline;
 IF OBJECT_ID('tempdb..#baselinewritten') IS NOT NULL
 	DROP TABLE #baselinewritten;
-
 SELECT DB_NAME(mf.database_id) AS databaseName ,
     mf.physical_name,
     divfs.num_of_bytes_read,
     divfs.num_of_bytes_written,
 	divfs.num_of_reads,
 	divfs.num_of_writes,
-    GETDATE() AS baselineDate
+    GETDATE() AS baselinedate
 INTO #baseline
 FROM sys.dm_io_virtual_file_stats(NULL, NULL) AS divfs
 INNER JOIN sys.master_files AS mf ON mf.database_id = divfs.database_id
 	AND mf.file_id = divfs.file_id
-
 WAITFOR DELAY @delayInterval;
-
 ;WITH currentLine AS
 (
 	SELECT DB_NAME(mf.database_id) AS databaseName ,
@@ -653,12 +651,11 @@ WAITFOR DELAY @delayInterval;
 		divfs.num_of_bytes_written,
 		divfs.num_of_reads,
 	    divfs.num_of_writes,
-		GETDATE() AS currentlineDate
+		GETDATE() AS currentlinedate
 	FROM sys.dm_io_virtual_file_stats(NULL, NULL) AS divfs
 	INNER JOIN sys.master_files AS mf ON mf.database_id = divfs.database_id
 			AND mf.file_id = divfs.file_id
 )
-
 SELECT database_name
 , datafile_type
 , num_of_bytes_read_persec = SUM(num_of_bytes_read_persec)
@@ -671,23 +668,21 @@ FROM
 SELECT
   database_name = currentLine.databaseName
 , datafile_type = type_desc
-, num_of_bytes_read_persec = (currentLine.num_of_bytes_read - T1.num_of_bytes_read) / (DATEDIFF(SECOND,baseLineDate,currentLineDate))
-, num_of_bytes_written_persec = (currentLine.num_of_bytes_written - T1.num_of_bytes_written) / (DATEDIFF(SECOND,baseLineDate,currentLineDate))
-, num_of_reads_persec =  (currentLine.num_of_reads - T1.num_of_reads) / (DATEDIFF(SECOND,baseLineDate,currentLineDate))
-, num_of_writes_persec =  (currentLine.num_of_writes - T1.num_of_writes) / (DATEDIFF(SECOND,baseLineDate,currentLineDate))
+, num_of_bytes_read_persec = (currentLine.num_of_bytes_read - T1.num_of_bytes_read) / (DATEDIFF(SECOND,baselinedate,currentlinedate))
+, num_of_bytes_written_persec = (currentLine.num_of_bytes_written - T1.num_of_bytes_written) / (DATEDIFF(SECOND,baselinedate,currentlinedate))
+, num_of_reads_persec =  (currentLine.num_of_reads - T1.num_of_reads) / (DATEDIFF(SECOND,baselinedate,currentlinedate))
+, num_of_writes_persec =  (currentLine.num_of_writes - T1.num_of_writes) / (DATEDIFF(SECOND,baselinedate,currentlinedate))
 FROM currentLine
 INNER JOIN #baseline T1 ON T1.databaseName = currentLine.databaseName
 	AND T1.physical_name = currentLine.physical_name
 ) as T
 GROUP BY database_name, datafile_type
-
 DECLARE @DynamicPivotQuery AS NVARCHAR(MAX)
 DECLARE @ColumnName AS NVARCHAR(MAX), @ColumnName2 AS NVARCHAR(MAX)
 SELECT @ColumnName = ISNULL(@ColumnName + ',','') + QUOTENAME(database_name)
 	FROM (SELECT DISTINCT database_name FROM #baselinewritten) AS bl
 SELECT @ColumnName2 = ISNULL(@ColumnName2 + '+','') + QUOTENAME(database_name)
 	FROM (SELECT DISTINCT database_name FROM #baselinewritten) AS bl
-
 SET @DynamicPivotQuery = N'
 SELECT measurement = ''Log writes (bytes/sec)'', servername = REPLACE(@@SERVERNAME, ''\'', '':''), type = ''Database IO''
 , ' + @ColumnName + ', Total = ' + @ColumnName2 + ' FROM
@@ -697,9 +692,7 @@ FROM #baselinewritten
 WHERE datafile_type = ''LOG''
 ) as V
 PIVOT(SUM(num_of_bytes_written_persec) FOR database_name IN (' + @ColumnName + ')) AS PVTTable
-
 UNION ALL
-
 SELECT measurement = ''Rows writes (bytes/sec)'', servername = REPLACE(@@SERVERNAME, ''\'', '':''), type = ''Database IO''
 , ' + @ColumnName + ', Total = ' + @ColumnName2 + ' FROM
 (
@@ -708,9 +701,7 @@ FROM #baselinewritten
 WHERE datafile_type = ''ROWS''
 ) as V
 PIVOT(SUM(num_of_bytes_written_persec) FOR database_name IN (' + @ColumnName + ')) AS PVTTable
-
 UNION ALL
-
 SELECT measurement = ''Log reads (bytes/sec)'', servername = REPLACE(@@SERVERNAME, ''\'', '':''), type = ''Database IO''
 , ' + @ColumnName + ', Total = ' + @ColumnName2 + ' FROM
 (
@@ -719,9 +710,7 @@ FROM #baselinewritten
 WHERE datafile_type = ''LOG''
 ) as V
 PIVOT(SUM(num_of_bytes_read_persec) FOR database_name IN (' + @ColumnName + ')) AS PVTTable
-
 UNION ALL
-
 SELECT measurement = ''Rows reads (bytes/sec)'', servername = REPLACE(@@SERVERNAME, ''\'', '':''), type = ''Database IO''
 , ' + @ColumnName + ', Total = ' + @ColumnName2 + ' FROM
 (
@@ -730,9 +719,7 @@ FROM #baselinewritten
 WHERE datafile_type = ''ROWS''
 ) as V
 PIVOT(SUM(num_of_bytes_read_persec) FOR database_name IN (' + @ColumnName + ')) AS PVTTable
-
 UNION ALL
-
 SELECT measurement = ''Log (writes/sec)'', servername = REPLACE(@@SERVERNAME, ''\'', '':''), type = ''Database IO''
 , ' + @ColumnName + ', Total = ' + @ColumnName2 + ' FROM
 (
@@ -741,9 +728,7 @@ FROM #baselinewritten
 WHERE datafile_type = ''LOG''
 ) as V
 PIVOT(SUM(num_of_writes_persec) FOR database_name IN (' + @ColumnName + ')) AS PVTTable
-
 UNION ALL
-
 SELECT measurement = ''Rows (writes/sec)'', servername = REPLACE(@@SERVERNAME, ''\'', '':''), type = ''Database IO''
 , ' + @ColumnName + ', Total = ' + @ColumnName2 + ' FROM
 (
@@ -752,9 +737,7 @@ FROM #baselinewritten
 WHERE datafile_type = ''ROWS''
 ) as V
 PIVOT(SUM(num_of_writes_persec) FOR database_name IN (' + @ColumnName + ')) AS PVTTabl
-
 UNION ALL
-
 SELECT measurement = ''Log (reads/sec)'', servername = REPLACE(@@SERVERNAME, ''\'', '':''), type = ''Database IO''
 , ' + @ColumnName + ', Total = ' + @ColumnName2 + ' FROM
 (
@@ -763,9 +746,7 @@ FROM #baselinewritten
 WHERE datafile_type = ''LOG''
 ) as V
 PIVOT(SUM(num_of_reads_persec) FOR database_name IN (' + @ColumnName + ')) AS PVTTable
-
 UNION ALL
-
 SELECT measurement = ''Rows (reads/sec)'', servername = REPLACE(@@SERVERNAME, ''\'', '':''), type = ''Database IO''
 , ' + @ColumnName + ', Total = ' + @ColumnName2 + ' FROM
 (
@@ -775,7 +756,6 @@ WHERE datafile_type = ''ROWS''
 ) as V
 PIVOT(SUM(num_of_reads_persec) FOR database_name IN (' + @ColumnName + ')) AS PVTTable
 '
-
 EXEC sp_executesql @DynamicPivotQuery;
 `
 

plugins/inputs/sqlserver/sqlserver_test.go

@@ -53,7 +53,9 @@ func TestSqlServer_ParseMetrics(t *testing.T) {
 					require.NoError(t, err)
 
 					// add value to Accumulator
-					acc.Add(measurement, value, tags, time.Now())
+					acc.AddFields(measurement,
+						map[string]interface{}{"value": value},
+						tags, time.Now())
 					// assert
 					acc.AssertContainsTaggedFields(t, measurement, map[string]interface{}{"value": value}, tags)
 

plugins/inputs/statsd/statsd.go

@@ -28,7 +28,7 @@ const (
 	defaultAllowPendingMessage = 10000
 )
 
-var dropwarn = "ERROR: statsd message queue full. " +
+var dropwarn = "E! Error: statsd message queue full. " +
 	"We have dropped %d messages so far. " +
 	"You may want to increase allowed_pending_messages in the config\n"
 
@@ -86,6 +86,8 @@ type Statsd struct {
 	Templates []string
 
 	listener *net.UDPConn
+
+	graphiteParser *graphite.GraphiteParser
 }
 
 // One statsd metric, form is <bucket>:<value>|<mtype>|@<samplerate>
@@ -249,7 +251,7 @@ func (s *Statsd) Start(_ telegraf.Accumulator) error {
 	}
 
 	if s.ConvertNames {
-		log.Printf("WARNING statsd: convert_names config option is deprecated," +
+		log.Printf("I! WARNING statsd: convert_names config option is deprecated," +
 			" please use metric_separator instead")
 	}
 
@@ -262,7 +264,7 @@ func (s *Statsd) Start(_ telegraf.Accumulator) error {
 	go s.udpListen()
 	// Start the line parser
 	go s.parser()
-	log.Printf("Started the statsd service on %s\n", s.ServiceAddress)
+	log.Printf("I! Started the statsd service on %s\n", s.ServiceAddress)
 	prevInstance = s
 	return nil
 }
@@ -276,7 +278,7 @@ func (s *Statsd) udpListen() error {
 	if err != nil {
 		log.Fatalf("ERROR: ListenUDP - %s", err)
 	}
-	log.Println("Statsd listener listening on: ", s.listener.LocalAddr().String())
+	log.Println("I! Statsd listener listening on: ", s.listener.LocalAddr().String())
 
 	buf := make([]byte, UDP_MAX_PACKET_SIZE)
 	for {
@@ -286,7 +288,7 @@ func (s *Statsd) udpListen() error {
 		default:
 			n, _, err := s.listener.ReadFromUDP(buf)
 			if err != nil && !strings.Contains(err.Error(), "closed network") {
-				log.Printf("ERROR READ: %s\n", err.Error())
+				log.Printf("E! Error READ: %s\n", err.Error())
 				continue
 			}
 			bufCopy := make([]byte, n)
@@ -347,7 +349,7 @@ func (s *Statsd) parseStatsdLine(line string) error {
 				tagstr := segment[1:]
 				tags := strings.Split(tagstr, ",")
 				for _, tag := range tags {
-					ts := strings.Split(tag, ":")
+					ts := strings.SplitN(tag, ":", 2)
 					var k, v string
 					switch len(ts) {
 					case 1:
@@ -372,7 +374,7 @@ func (s *Statsd) parseStatsdLine(line string) error {
 	// Validate splitting the line on ":"
 	bits := strings.Split(line, ":")
 	if len(bits) < 2 {
-		log.Printf("Error: splitting ':', Unable to parse metric: %s\n", line)
+		log.Printf("E! Error: splitting ':', Unable to parse metric: %s\n", line)
 		return errors.New("Error Parsing statsd line")
 	}
 
@@ -388,11 +390,11 @@ func (s *Statsd) parseStatsdLine(line string) error {
 		// Validate splitting the bit on "|"
 		pipesplit := strings.Split(bit, "|")
 		if len(pipesplit) < 2 {
-			log.Printf("Error: splitting '|', Unable to parse metric: %s\n", line)
+			log.Printf("E! Error: splitting '|', Unable to parse metric: %s\n", line)
 			return errors.New("Error Parsing statsd line")
 		} else if len(pipesplit) > 2 {
 			sr := pipesplit[2]
-			errmsg := "Error: parsing sample rate, %s, it must be in format like: " +
+			errmsg := "E! Error: parsing sample rate, %s, it must be in format like: " +
 				"@0.1, @0.5, etc. Ignoring sample rate for line: %s\n"
 			if strings.Contains(sr, "@") && len(sr) > 1 {
 				samplerate, err := strconv.ParseFloat(sr[1:], 64)
@@ -412,14 +414,14 @@ func (s *Statsd) parseStatsdLine(line string) error {
 		case "g", "c", "s", "ms", "h":
 			m.mtype = pipesplit[1]
 		default:
-			log.Printf("Error: Statsd Metric type %s unsupported", pipesplit[1])
+			log.Printf("E! Error: Statsd Metric type %s unsupported", pipesplit[1])
 			return errors.New("Error Parsing statsd line")
 		}
 
 		// Parse the value
-		if strings.ContainsAny(pipesplit[0], "-+") {
+		if strings.HasPrefix(pipesplit[0], "-") || strings.HasPrefix(pipesplit[0], "+") {
 			if m.mtype != "g" {
-				log.Printf("Error: +- values are only supported for gauges: %s\n", line)
+				log.Printf("E! Error: +- values are only supported for gauges: %s\n", line)
 				return errors.New("Error Parsing statsd line")
 			}
 			m.additive = true
@@ -429,7 +431,7 @@ func (s *Statsd) parseStatsdLine(line string) error {
 		case "g", "ms", "h":
 			v, err := strconv.ParseFloat(pipesplit[0], 64)
 			if err != nil {
-				log.Printf("Error: parsing value to float64: %s\n", line)
+				log.Printf("E! Error: parsing value to float64: %s\n", line)
 				return errors.New("Error Parsing statsd line")
 			}
 			m.floatvalue = v
@@ -439,7 +441,7 @@ func (s *Statsd) parseStatsdLine(line string) error {
 			if err != nil {
 				v2, err2 := strconv.ParseFloat(pipesplit[0], 64)
 				if err2 != nil {
-					log.Printf("Error: parsing value to int64: %s\n", line)
+					log.Printf("E! Error: parsing value to int64: %s\n", line)
 					return errors.New("Error Parsing statsd line")
 				}
 				v = int64(v2)
@@ -506,7 +508,15 @@ func (s *Statsd) parseName(bucket string) (string, string, map[string]string) {
 
 	var field string
 	name := bucketparts[0]
-	p, err := graphite.NewGraphiteParser(s.MetricSeparator, s.Templates, nil)
+
+	p := s.graphiteParser
+	var err error
+
+	if p == nil || s.graphiteParser.Separator != s.MetricSeparator {
+		p, err = graphite.NewGraphiteParser(s.MetricSeparator, s.Templates, nil)
+		s.graphiteParser = p
+	}
+
 	if err == nil {
 		p.DefaultTags = tags
 		name, tags, field, _ = p.ApplyTemplate(name)
@@ -631,7 +641,7 @@ func (s *Statsd) aggregate(m metric) {
 func (s *Statsd) Stop() {
 	s.Lock()
 	defer s.Unlock()
-	log.Println("Stopping the statsd service")
+	log.Println("I! Stopping the statsd service")
 	close(s.done)
 	s.listener.Close()
 	s.wg.Wait()

plugins/inputs/statsd/statsd_test.go

@@ -24,6 +24,267 @@ func NewTestStatsd() *Statsd {
 	return &s
 }
 
+// Valid lines should be parsed and their values should be cached
+func TestParse_ValidLines(t *testing.T) {
+	s := NewTestStatsd()
+	valid_lines := []string{
+		"valid:45|c",
+		"valid:45|s",
+		"valid:45|g",
+		"valid.timer:45|ms",
+		"valid.timer:45|h",
+	}
+
+	for _, line := range valid_lines {
+		err := s.parseStatsdLine(line)
+		if err != nil {
+			t.Errorf("Parsing line %s should not have resulted in an error\n", line)
+		}
+	}
+}
+
+// Tests low-level functionality of gauges
+func TestParse_Gauges(t *testing.T) {
+	s := NewTestStatsd()
+
+	// Test that gauge +- values work
+	valid_lines := []string{
+		"plus.minus:100|g",
+		"plus.minus:-10|g",
+		"plus.minus:+30|g",
+		"plus.plus:100|g",
+		"plus.plus:+100|g",
+		"plus.plus:+100|g",
+		"minus.minus:100|g",
+		"minus.minus:-100|g",
+		"minus.minus:-100|g",
+		"lone.plus:+100|g",
+		"lone.minus:-100|g",
+		"overwrite:100|g",
+		"overwrite:300|g",
+		"scientific.notation:4.696E+5|g",
+		"scientific.notation.minus:4.7E-5|g",
+	}
+
+	for _, line := range valid_lines {
+		err := s.parseStatsdLine(line)
+		if err != nil {
+			t.Errorf("Parsing line %s should not have resulted in an error\n", line)
+		}
+	}
+
+	validations := []struct {
+		name  string
+		value float64
+	}{
+		{
+			"scientific_notation",
+			469600,
+		},
+		{
+			"scientific_notation_minus",
+			0.000047,
+		},
+		{
+			"plus_minus",
+			120,
+		},
+		{
+			"plus_plus",
+			300,
+		},
+		{
+			"minus_minus",
+			-100,
+		},
+		{
+			"lone_plus",
+			100,
+		},
+		{
+			"lone_minus",
+			-100,
+		},
+		{
+			"overwrite",
+			300,
+		},
+	}
+
+	for _, test := range validations {
+		err := test_validate_gauge(test.name, test.value, s.gauges)
+		if err != nil {
+			t.Error(err.Error())
+		}
+	}
+}
+
+// Tests low-level functionality of sets
+func TestParse_Sets(t *testing.T) {
+	s := NewTestStatsd()
+
+	// Test that sets work
+	valid_lines := []string{
+		"unique.user.ids:100|s",
+		"unique.user.ids:100|s",
+		"unique.user.ids:100|s",
+		"unique.user.ids:100|s",
+		"unique.user.ids:100|s",
+		"unique.user.ids:101|s",
+		"unique.user.ids:102|s",
+		"unique.user.ids:102|s",
+		"unique.user.ids:123456789|s",
+		"oneuser.id:100|s",
+		"oneuser.id:100|s",
+		"scientific.notation.sets:4.696E+5|s",
+		"scientific.notation.sets:4.696E+5|s",
+		"scientific.notation.sets:4.697E+5|s",
+	}
+
+	for _, line := range valid_lines {
+		err := s.parseStatsdLine(line)
+		if err != nil {
+			t.Errorf("Parsing line %s should not have resulted in an error\n", line)
+		}
+	}
+
+	validations := []struct {
+		name  string
+		value int64
+	}{
+		{
+			"scientific_notation_sets",
+			2,
+		},
+		{
+			"unique_user_ids",
+			4,
+		},
+		{
+			"oneuser_id",
+			1,
+		},
+	}
+
+	for _, test := range validations {
+		err := test_validate_set(test.name, test.value, s.sets)
+		if err != nil {
+			t.Error(err.Error())
+		}
+	}
+}
+
+// Tests low-level functionality of counters
+func TestParse_Counters(t *testing.T) {
+	s := NewTestStatsd()
+
+	// Test that counters work
+	valid_lines := []string{
+		"small.inc:1|c",
+		"big.inc:100|c",
+		"big.inc:1|c",
+		"big.inc:100000|c",
+		"big.inc:1000000|c",
+		"small.inc:1|c",
+		"zero.init:0|c",
+		"sample.rate:1|c|@0.1",
+		"sample.rate:1|c",
+		"scientific.notation:4.696E+5|c",
+	}
+
+	for _, line := range valid_lines {
+		err := s.parseStatsdLine(line)
+		if err != nil {
+			t.Errorf("Parsing line %s should not have resulted in an error\n", line)
+		}
+	}
+
+	validations := []struct {
+		name  string
+		value int64
+	}{
+		{
+			"scientific_notation",
+			469600,
+		},
+		{
+			"small_inc",
+			2,
+		},
+		{
+			"big_inc",
+			1100101,
+		},
+		{
+			"zero_init",
+			0,
+		},
+		{
+			"sample_rate",
+			11,
+		},
+	}
+
+	for _, test := range validations {
+		err := test_validate_counter(test.name, test.value, s.counters)
+		if err != nil {
+			t.Error(err.Error())
+		}
+	}
+}
+
+// Tests low-level functionality of timings
+func TestParse_Timings(t *testing.T) {
+	s := NewTestStatsd()
+	s.Percentiles = []int{90}
+	acc := &testutil.Accumulator{}
+
+	// Test that counters work
+	valid_lines := []string{
+		"test.timing:1|ms",
+		"test.timing:11|ms",
+		"test.timing:1|ms",
+		"test.timing:1|ms",
+		"test.timing:1|ms",
+	}
+
+	for _, line := range valid_lines {
+		err := s.parseStatsdLine(line)
+		if err != nil {
+			t.Errorf("Parsing line %s should not have resulted in an error\n", line)
+		}
+	}
+
+	s.Gather(acc)
+
+	valid := map[string]interface{}{
+		"90_percentile": float64(11),
+		"count":         int64(5),
+		"lower":         float64(1),
+		"mean":          float64(3),
+		"stddev":        float64(4),
+		"upper":         float64(11),
+	}
+
+	acc.AssertContainsFields(t, "test_timing", valid)
+}
+
+func TestParseScientificNotation(t *testing.T) {
+	s := NewTestStatsd()
+	sciNotationLines := []string{
+		"scientific.notation:4.6968460083008E-5|ms",
+		"scientific.notation:4.6968460083008E-5|g",
+		"scientific.notation:4.6968460083008E-5|c",
+		"scientific.notation:4.6968460083008E-5|h",
+	}
+	for _, line := range sciNotationLines {
+		err := s.parseStatsdLine(line)
+		if err != nil {
+			t.Errorf("Parsing line [%s] should not have resulted in error: %s\n", line, err)
+		}
+	}
+}
+
 // Invalid lines should return an error
 func TestParse_InvalidLines(t *testing.T) {
 	s := NewTestStatsd()
@@ -432,7 +693,7 @@ func TestParse_DataDogTags(t *testing.T) {
 	s.ParseDataDogTags = true
 
 	lines := []string{
-		"my_counter:1|c|#host:localhost,environment:prod",
+		"my_counter:1|c|#host:localhost,environment:prod,endpoint:/:tenant?/oauth/ro",
 		"my_gauge:10.1|g|#live",
 		"my_set:1|s|#host:localhost",
 		"my_timer:3|ms|@0.1|#live,host:localhost",
@@ -442,6 +703,7 @@ func TestParse_DataDogTags(t *testing.T) {
 		"my_counter": map[string]string{
 			"host":        "localhost",
 			"environment": "prod",
+			"endpoint":    "/:tenant?/oauth/ro",
 		},
 
 		"my_gauge": map[string]string{
@@ -715,229 +977,6 @@ func TestParse_MeasurementsWithMultipleValues(t *testing.T) {
 	}
 }
 
-// Valid lines should be parsed and their values should be cached
-func TestParse_ValidLines(t *testing.T) {
-	s := NewTestStatsd()
-	valid_lines := []string{
-		"valid:45|c",
-		"valid:45|s",
-		"valid:45|g",
-		"valid.timer:45|ms",
-		"valid.timer:45|h",
-	}
-
-	for _, line := range valid_lines {
-		err := s.parseStatsdLine(line)
-		if err != nil {
-			t.Errorf("Parsing line %s should not have resulted in an error\n", line)
-		}
-	}
-}
-
-// Tests low-level functionality of gauges
-func TestParse_Gauges(t *testing.T) {
-	s := NewTestStatsd()
-
-	// Test that gauge +- values work
-	valid_lines := []string{
-		"plus.minus:100|g",
-		"plus.minus:-10|g",
-		"plus.minus:+30|g",
-		"plus.plus:100|g",
-		"plus.plus:+100|g",
-		"plus.plus:+100|g",
-		"minus.minus:100|g",
-		"minus.minus:-100|g",
-		"minus.minus:-100|g",
-		"lone.plus:+100|g",
-		"lone.minus:-100|g",
-		"overwrite:100|g",
-		"overwrite:300|g",
-	}
-
-	for _, line := range valid_lines {
-		err := s.parseStatsdLine(line)
-		if err != nil {
-			t.Errorf("Parsing line %s should not have resulted in an error\n", line)
-		}
-	}
-
-	validations := []struct {
-		name  string
-		value float64
-	}{
-		{
-			"plus_minus",
-			120,
-		},
-		{
-			"plus_plus",
-			300,
-		},
-		{
-			"minus_minus",
-			-100,
-		},
-		{
-			"lone_plus",
-			100,
-		},
-		{
-			"lone_minus",
-			-100,
-		},
-		{
-			"overwrite",
-			300,
-		},
-	}
-
-	for _, test := range validations {
-		err := test_validate_gauge(test.name, test.value, s.gauges)
-		if err != nil {
-			t.Error(err.Error())
-		}
-	}
-}
-
-// Tests low-level functionality of sets
-func TestParse_Sets(t *testing.T) {
-	s := NewTestStatsd()
-
-	// Test that sets work
-	valid_lines := []string{
-		"unique.user.ids:100|s",
-		"unique.user.ids:100|s",
-		"unique.user.ids:100|s",
-		"unique.user.ids:100|s",
-		"unique.user.ids:100|s",
-		"unique.user.ids:101|s",
-		"unique.user.ids:102|s",
-		"unique.user.ids:102|s",
-		"unique.user.ids:123456789|s",
-		"oneuser.id:100|s",
-		"oneuser.id:100|s",
-	}
-
-	for _, line := range valid_lines {
-		err := s.parseStatsdLine(line)
-		if err != nil {
-			t.Errorf("Parsing line %s should not have resulted in an error\n", line)
-		}
-	}
-
-	validations := []struct {
-		name  string
-		value int64
-	}{
-		{
-			"unique_user_ids",
-			4,
-		},
-		{
-			"oneuser_id",
-			1,
-		},
-	}
-
-	for _, test := range validations {
-		err := test_validate_set(test.name, test.value, s.sets)
-		if err != nil {
-			t.Error(err.Error())
-		}
-	}
-}
-
-// Tests low-level functionality of counters
-func TestParse_Counters(t *testing.T) {
-	s := NewTestStatsd()
-
-	// Test that counters work
-	valid_lines := []string{
-		"small.inc:1|c",
-		"big.inc:100|c",
-		"big.inc:1|c",
-		"big.inc:100000|c",
-		"big.inc:1000000|c",
-		"small.inc:1|c",
-		"zero.init:0|c",
-		"sample.rate:1|c|@0.1",
-		"sample.rate:1|c",
-	}
-
-	for _, line := range valid_lines {
-		err := s.parseStatsdLine(line)
-		if err != nil {
-			t.Errorf("Parsing line %s should not have resulted in an error\n", line)
-		}
-	}
-
-	validations := []struct {
-		name  string
-		value int64
-	}{
-		{
-			"small_inc",
-			2,
-		},
-		{
-			"big_inc",
-			1100101,
-		},
-		{
-			"zero_init",
-			0,
-		},
-		{
-			"sample_rate",
-			11,
-		},
-	}
-
-	for _, test := range validations {
-		err := test_validate_counter(test.name, test.value, s.counters)
-		if err != nil {
-			t.Error(err.Error())
-		}
-	}
-}
-
-// Tests low-level functionality of timings
-func TestParse_Timings(t *testing.T) {
-	s := NewTestStatsd()
-	s.Percentiles = []int{90}
-	acc := &testutil.Accumulator{}
-
-	// Test that counters work
-	valid_lines := []string{
-		"test.timing:1|ms",
-		"test.timing:11|ms",
-		"test.timing:1|ms",
-		"test.timing:1|ms",
-		"test.timing:1|ms",
-	}
-
-	for _, line := range valid_lines {
-		err := s.parseStatsdLine(line)
-		if err != nil {
-			t.Errorf("Parsing line %s should not have resulted in an error\n", line)
-		}
-	}
-
-	s.Gather(acc)
-
-	valid := map[string]interface{}{
-		"90_percentile": float64(11),
-		"count":         int64(5),
-		"lower":         float64(1),
-		"mean":          float64(3),
-		"stddev":        float64(4),
-		"upper":         float64(11),
-	}
-
-	acc.AssertContainsFields(t, "test_timing", valid)
-}
-
 // Tests low-level functionality of timings when multiple fields is enabled
 // and a measurement template has been defined which can parse field names
 func TestParse_Timings_MultipleFieldsWithTemplate(t *testing.T) {
@@ -1037,6 +1076,136 @@ func TestParse_Timings_MultipleFieldsWithoutTemplate(t *testing.T) {
 	acc.AssertContainsFields(t, "test_timing_error", expectedError)
 }
 
+func BenchmarkParse(b *testing.B) {
+	s := NewTestStatsd()
+	validLines := []string{
+		"test.timing.success:1|ms",
+		"test.timing.success:11|ms",
+		"test.timing.success:1|ms",
+		"test.timing.success:1|ms",
+		"test.timing.success:1|ms",
+		"test.timing.error:2|ms",
+		"test.timing.error:22|ms",
+		"test.timing.error:2|ms",
+		"test.timing.error:2|ms",
+		"test.timing.error:2|ms",
+	}
+	for n := 0; n < b.N; n++ {
+		for _, line := range validLines {
+			err := s.parseStatsdLine(line)
+			if err != nil {
+				b.Errorf("Parsing line %s should not have resulted in an error\n", line)
+			}
+		}
+	}
+}
+
+func BenchmarkParseWithTemplate(b *testing.B) {
+	s := NewTestStatsd()
+	s.Templates = []string{"measurement.measurement.field"}
+	validLines := []string{
+		"test.timing.success:1|ms",
+		"test.timing.success:11|ms",
+		"test.timing.success:1|ms",
+		"test.timing.success:1|ms",
+		"test.timing.success:1|ms",
+		"test.timing.error:2|ms",
+		"test.timing.error:22|ms",
+		"test.timing.error:2|ms",
+		"test.timing.error:2|ms",
+		"test.timing.error:2|ms",
+	}
+	for n := 0; n < b.N; n++ {
+		for _, line := range validLines {
+			err := s.parseStatsdLine(line)
+			if err != nil {
+				b.Errorf("Parsing line %s should not have resulted in an error\n", line)
+			}
+		}
+	}
+}
+
+func BenchmarkParseWithTemplateAndFilter(b *testing.B) {
+	s := NewTestStatsd()
+	s.Templates = []string{"cpu* measurement.measurement.field"}
+	validLines := []string{
+		"test.timing.success:1|ms",
+		"test.timing.success:11|ms",
+		"test.timing.success:1|ms",
+		"cpu.timing.success:1|ms",
+		"cpu.timing.success:1|ms",
+		"cpu.timing.error:2|ms",
+		"cpu.timing.error:22|ms",
+		"test.timing.error:2|ms",
+		"test.timing.error:2|ms",
+		"test.timing.error:2|ms",
+	}
+	for n := 0; n < b.N; n++ {
+		for _, line := range validLines {
+			err := s.parseStatsdLine(line)
+			if err != nil {
+				b.Errorf("Parsing line %s should not have resulted in an error\n", line)
+			}
+		}
+	}
+}
+
+func BenchmarkParseWith2TemplatesAndFilter(b *testing.B) {
+	s := NewTestStatsd()
+	s.Templates = []string{
+		"cpu1* measurement.measurement.field",
+		"cpu2* measurement.measurement.field",
+	}
+	validLines := []string{
+		"test.timing.success:1|ms",
+		"test.timing.success:11|ms",
+		"test.timing.success:1|ms",
+		"cpu1.timing.success:1|ms",
+		"cpu1.timing.success:1|ms",
+		"cpu2.timing.error:2|ms",
+		"cpu2.timing.error:22|ms",
+		"test.timing.error:2|ms",
+		"test.timing.error:2|ms",
+		"test.timing.error:2|ms",
+	}
+	for n := 0; n < b.N; n++ {
+		for _, line := range validLines {
+			err := s.parseStatsdLine(line)
+			if err != nil {
+				b.Errorf("Parsing line %s should not have resulted in an error\n", line)
+			}
+		}
+	}
+}
+
+func BenchmarkParseWith2Templates3TagsAndFilter(b *testing.B) {
+	s := NewTestStatsd()
+	s.Templates = []string{
+		"cpu1* measurement.measurement.region.city.rack.field",
+		"cpu2* measurement.measurement.region.city.rack.field",
+	}
+	validLines := []string{
+		"test.timing.us-east.nyc.rack01.success:1|ms",
+		"test.timing.us-east.nyc.rack01.success:11|ms",
+		"test.timing.us-west.sf.rack01.success:1|ms",
+		"cpu1.timing.us-west.sf.rack01.success:1|ms",
+		"cpu1.timing.us-east.nyc.rack01.success:1|ms",
+		"cpu2.timing.us-east.nyc.rack01.error:2|ms",
+		"cpu2.timing.us-west.sf.rack01.error:22|ms",
+		"test.timing.us-west.sf.rack01.error:2|ms",
+		"test.timing.us-west.sf.rack01.error:2|ms",
+		"test.timing.us-east.nyc.rack01.error:2|ms",
+	}
+	for n := 0; n < b.N; n++ {
+		for _, line := range validLines {
+			err := s.parseStatsdLine(line)
+			if err != nil {
+				b.Errorf("Parsing line %s should not have resulted in an error\n", line)
+			}
+		}
+	}
+}
+
 func TestParse_Timings_Delete(t *testing.T) {
 	s := NewTestStatsd()
 	s.DeleteTimings = true

plugins/inputs/sysstat/sysstat.go

@@ -8,6 +8,7 @@ import (
 	"errors"
 	"fmt"
 	"io"
+	"log"
 	"os"
 	"os/exec"
 	"path"
@@ -201,6 +202,9 @@ func (s *Sysstat) collect() error {
 	cmd := execCommand(s.Sadc, options...)
 	out, err := internal.CombinedOutputTimeout(cmd, time.Second*time.Duration(collectInterval+parseInterval))
 	if err != nil {
+		if err := os.Remove(s.tmpFile); err != nil {
+			log.Printf("E! failed to remove tmp file after %s command: %s", strings.Join(cmd.Args, " "), err)
+		}
 		return fmt.Errorf("failed to run command %s: %s - %s", strings.Join(cmd.Args, " "), err, string(out))
 	}
 	return nil

plugins/inputs/system/cpu.go

@@ -13,13 +13,15 @@ type CPUStats struct {
 	ps        PS
 	lastStats []cpu.TimesStat
 
-	PerCPU   bool `toml:"percpu"`
-	TotalCPU bool `toml:"totalcpu"`
+	PerCPU         bool `toml:"percpu"`
+	TotalCPU       bool `toml:"totalcpu"`
+	CollectCPUTime bool `toml:"collect_cpu_time"`
 }
 
 func NewCPUStats(ps PS) *CPUStats {
 	return &CPUStats{
-		ps: ps,
+		ps:             ps,
+		CollectCPUTime: true,
 	}
 }
 
@@ -32,8 +34,8 @@ var sampleConfig = `
   percpu = true
   ## Whether to report total system cpu stats or not
   totalcpu = true
-  ## Comment this line if you want the raw CPU time metrics
-  fielddrop = ["time_*"]
+  ## If true, collect raw CPU time metrics.
+  collect_cpu_time = false
 `
 
 func (_ *CPUStats) SampleConfig() string {
@@ -54,23 +56,25 @@ func (s *CPUStats) Gather(acc telegraf.Accumulator) error {
 
 		total := totalCpuTime(cts)
 
-		// Add cpu time metrics
-		fields := map[string]interface{}{
-			"time_user":       cts.User,
-			"time_system":     cts.System,
-			"time_idle":       cts.Idle,
-			"time_nice":       cts.Nice,
-			"time_iowait":     cts.Iowait,
-			"time_irq":        cts.Irq,
-			"time_softirq":    cts.Softirq,
-			"time_steal":      cts.Steal,
-			"time_guest":      cts.Guest,
-			"time_guest_nice": cts.GuestNice,
+		if s.CollectCPUTime {
+			// Add cpu time metrics
+			fieldsC := map[string]interface{}{
+				"time_user":       cts.User,
+				"time_system":     cts.System,
+				"time_idle":       cts.Idle,
+				"time_nice":       cts.Nice,
+				"time_iowait":     cts.Iowait,
+				"time_irq":        cts.Irq,
+				"time_softirq":    cts.Softirq,
+				"time_steal":      cts.Steal,
+				"time_guest":      cts.Guest,
+				"time_guest_nice": cts.GuestNice,
+			}
+			acc.AddCounter("cpu", fieldsC, tags, now)
 		}
 
 		// Add in percentage
 		if len(s.lastStats) == 0 {
-			acc.AddFields("cpu", fields, tags, now)
 			// If it's the 1st gather, can't get CPU Usage stats yet
 			continue
 		}
@@ -86,18 +90,19 @@ func (s *CPUStats) Gather(acc telegraf.Accumulator) error {
 		if totalDelta == 0 {
 			continue
 		}
-
-		fields["usage_user"] = 100 * (cts.User - lastCts.User) / totalDelta
-		fields["usage_system"] = 100 * (cts.System - lastCts.System) / totalDelta
-		fields["usage_idle"] = 100 * (cts.Idle - lastCts.Idle) / totalDelta
-		fields["usage_nice"] = 100 * (cts.Nice - lastCts.Nice) / totalDelta
-		fields["usage_iowait"] = 100 * (cts.Iowait - lastCts.Iowait) / totalDelta
-		fields["usage_irq"] = 100 * (cts.Irq - lastCts.Irq) / totalDelta
-		fields["usage_softirq"] = 100 * (cts.Softirq - lastCts.Softirq) / totalDelta
-		fields["usage_steal"] = 100 * (cts.Steal - lastCts.Steal) / totalDelta
-		fields["usage_guest"] = 100 * (cts.Guest - lastCts.Guest) / totalDelta
-		fields["usage_guest_nice"] = 100 * (cts.GuestNice - lastCts.GuestNice) / totalDelta
-		acc.AddFields("cpu", fields, tags, now)
+		fieldsG := map[string]interface{}{
+			"usage_user":       100 * (cts.User - lastCts.User) / totalDelta,
+			"usage_system":     100 * (cts.System - lastCts.System) / totalDelta,
+			"usage_idle":       100 * (cts.Idle - lastCts.Idle) / totalDelta,
+			"usage_nice":       100 * (cts.Nice - lastCts.Nice) / totalDelta,
+			"usage_iowait":     100 * (cts.Iowait - lastCts.Iowait) / totalDelta,
+			"usage_irq":        100 * (cts.Irq - lastCts.Irq) / totalDelta,
+			"usage_softirq":    100 * (cts.Softirq - lastCts.Softirq) / totalDelta,
+			"usage_steal":      100 * (cts.Steal - lastCts.Steal) / totalDelta,
+			"usage_guest":      100 * (cts.Guest - lastCts.Guest) / totalDelta,
+			"usage_guest_nice": 100 * (cts.GuestNice - lastCts.GuestNice) / totalDelta,
+		}
+		acc.AddGauge("cpu", fieldsG, tags, now)
 	}
 
 	s.lastStats = times

plugins/inputs/system/disk.go

@@ -70,7 +70,7 @@ func (s *DiskStats) Gather(acc telegraf.Accumulator) error {
 			"inodes_free":  du.InodesFree,
 			"inodes_used":  du.InodesUsed,
 		}
-		acc.AddFields("disk", fields, tags)
+		acc.AddGauge("disk", fields, tags)
 	}
 
 	return nil
@@ -139,7 +139,7 @@ func (s *DiskIOStats) Gather(acc telegraf.Accumulator) error {
 			"write_time":  io.WriteTime,
 			"io_time":     io.IoTime,
 		}
-		acc.AddFields("diskio", fields, tags)
+		acc.AddCounter("diskio", fields, tags)
 	}
 
 	return nil