renaming plugins -> inputs

plugins/inputs/exec/README.md

@@ -0,0 +1,42 @@
+# Exec Plugin
+
+The exec plugin can execute arbitrary commands which output JSON. Then it flattens JSON and finds
+all numeric values, treating them as floats.
+
+For example, if you have a json-returning command called mycollector, you could
+setup the exec plugin with:
+
+```
+[[exec.commands]]
+command = "/usr/bin/mycollector --output=json"
+name = "mycollector"
+interval = 10
+```
+
+The name is used as a prefix for the measurements.
+
+The interval is used to determine how often a particular command should be run. Each
+time the exec plugin runs, it will only run a particular command if it has been at least
+`interval` seconds since the exec plugin last ran the command.
+
+
+# Sample
+
+Let's say that we have a command named "mycollector", which gives the following output:
+```json
+{
+    "a": 0.5,
+    "b": {
+        "c": "some text",
+        "d": 0.1,
+        "e": 5
+    }
+}
+```
+
+The collected metrics will be:
+```
+exec_mycollector_a value=0.5
+exec_mycollector_b_d value=0.1
+exec_mycollector_b_e value=5
+```

plugins/inputs/exec/exec.go

@@ -0,0 +1,91 @@
+package exec
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"os/exec"
+
+	"github.com/gonuts/go-shellquote"
+
+	"github.com/influxdb/telegraf/internal"
+	"github.com/influxdb/telegraf/plugins/inputs"
+)
+
+const sampleConfig = `
+  # the command to run
+  command = "/usr/bin/mycollector --foo=bar"
+
+  # measurement name suffix (for separating different commands)
+  name_suffix = "_mycollector"
+`
+
+type Exec struct {
+	Command string
+
+	runner Runner
+}
+
+type Runner interface {
+	Run(*Exec) ([]byte, error)
+}
+
+type CommandRunner struct{}
+
+func (c CommandRunner) Run(e *Exec) ([]byte, error) {
+	split_cmd, err := shellquote.Split(e.Command)
+	if err != nil || len(split_cmd) == 0 {
+		return nil, fmt.Errorf("exec: unable to parse command, %s", err)
+	}
+
+	cmd := exec.Command(split_cmd[0], split_cmd[1:]...)
+	var out bytes.Buffer
+	cmd.Stdout = &out
+
+	if err := cmd.Run(); err != nil {
+		return nil, fmt.Errorf("exec: %s for command '%s'", err, e.Command)
+	}
+
+	return out.Bytes(), nil
+}
+
+func NewExec() *Exec {
+	return &Exec{runner: CommandRunner{}}
+}
+
+func (e *Exec) SampleConfig() string {
+	return sampleConfig
+}
+
+func (e *Exec) Description() string {
+	return "Read flattened metrics from one or more commands that output JSON to stdout"
+}
+
+func (e *Exec) Gather(acc inputs.Accumulator) error {
+	out, err := e.runner.Run(e)
+	if err != nil {
+		return err
+	}
+
+	var jsonOut interface{}
+	err = json.Unmarshal(out, &jsonOut)
+	if err != nil {
+		return fmt.Errorf("exec: unable to parse output of '%s' as JSON, %s",
+			e.Command, err)
+	}
+
+	f := internal.JSONFlattener{}
+	err = f.FlattenJSON("", jsonOut)
+	if err != nil {
+		return err
+	}
+
+	acc.AddFields("exec", f.Fields, nil)
+	return nil
+}
+
+func init() {
+	inputs.Add("exec", func() inputs.Input {
+		return NewExec()
+	})
+}

plugins/inputs/exec/exec_test.go

@@ -0,0 +1,95 @@
+package exec
+
+import (
+	"fmt"
+	"testing"
+
+	"github.com/influxdb/telegraf/testutil"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+// Midnight 9/22/2015
+const baseTimeSeconds = 1442905200
+
+const validJson = `
+{
+    "status": "green",
+    "num_processes": 82,
+    "cpu": {
+        "status": "red",
+        "nil_status": null,
+        "used": 8234,
+        "free": 32
+    },
+    "percent": 0.81,
+    "users": [0, 1, 2, 3]
+}`
+
+const malformedJson = `
+{
+    "status": "green",
+`
+
+type runnerMock struct {
+	out []byte
+	err error
+}
+
+func newRunnerMock(out []byte, err error) Runner {
+	return &runnerMock{
+		out: out,
+		err: err,
+	}
+}
+
+func (r runnerMock) Run(e *Exec) ([]byte, error) {
+	if r.err != nil {
+		return nil, r.err
+	}
+	return r.out, nil
+}
+
+func TestExec(t *testing.T) {
+	e := &Exec{
+		runner:  newRunnerMock([]byte(validJson), nil),
+		Command: "testcommand arg1",
+	}
+
+	var acc testutil.Accumulator
+	err := e.Gather(&acc)
+	require.NoError(t, err)
+	assert.Equal(t, acc.NFields(), 4, "non-numeric measurements should be ignored")
+
+	fields := map[string]interface{}{
+		"num_processes": float64(82),
+		"cpu_used":      float64(8234),
+		"cpu_free":      float64(32),
+		"percent":       float64(0.81),
+	}
+	acc.AssertContainsFields(t, "exec", fields)
+}
+
+func TestExecMalformed(t *testing.T) {
+	e := &Exec{
+		runner:  newRunnerMock([]byte(malformedJson), nil),
+		Command: "badcommand arg1",
+	}
+
+	var acc testutil.Accumulator
+	err := e.Gather(&acc)
+	require.Error(t, err)
+	assert.Equal(t, acc.NFields(), 0, "No new points should have been added")
+}
+
+func TestCommandError(t *testing.T) {
+	e := &Exec{
+		runner:  newRunnerMock(nil, fmt.Errorf("exit status code 1")),
+		Command: "badcommand",
+	}
+
+	var acc testutil.Accumulator
+	err := e.Gather(&acc)
+	require.Error(t, err)
+	assert.Equal(t, acc.NFields(), 0, "No new points should have been added")
+}