Add Serializer plugins, and 'file' output plugin

plugins/serializers/graphite/graphite.go

@@ -0,0 +1,79 @@
+package graphite
+
+import (
+	"fmt"
+	"sort"
+	"strings"
+
+	"github.com/influxdata/telegraf"
+)
+
+type GraphiteSerializer struct {
+	Prefix string
+}
+
+func (s *GraphiteSerializer) Serialize(metric telegraf.Metric) ([]string, error) {
+	out := []string{}
+	// Get name
+	name := metric.Name()
+	// Convert UnixNano to Unix timestamps
+	timestamp := metric.UnixNano() / 1000000000
+	tag_str := buildTags(metric)
+
+	for field_name, value := range metric.Fields() {
+		// Convert value
+		value_str := fmt.Sprintf("%#v", value)
+		// Write graphite metric
+		var graphitePoint string
+		if name == field_name {
+			graphitePoint = fmt.Sprintf("%s.%s %s %d",
+				tag_str,
+				strings.Replace(name, ".", "_", -1),
+				value_str,
+				timestamp)
+		} else {
+			graphitePoint = fmt.Sprintf("%s.%s.%s %s %d",
+				tag_str,
+				strings.Replace(name, ".", "_", -1),
+				strings.Replace(field_name, ".", "_", -1),
+				value_str,
+				timestamp)
+		}
+		if s.Prefix != "" {
+			graphitePoint = fmt.Sprintf("%s.%s", s.Prefix, graphitePoint)
+		}
+		out = append(out, graphitePoint)
+	}
+	return out, nil
+}
+
+func buildTags(metric telegraf.Metric) string {
+	var keys []string
+	tags := metric.Tags()
+	for k := range tags {
+		if k == "host" {
+			continue
+		}
+		keys = append(keys, k)
+	}
+	sort.Strings(keys)
+
+	var tag_str string
+	if host, ok := tags["host"]; ok {
+		if len(keys) > 0 {
+			tag_str = strings.Replace(host, ".", "_", -1) + "."
+		} else {
+			tag_str = strings.Replace(host, ".", "_", -1)
+		}
+	}
+
+	for i, k := range keys {
+		tag_value := strings.Replace(tags[k], ".", "_", -1)
+		if i == 0 {
+			tag_str += tag_value
+		} else {
+			tag_str += "." + tag_value
+		}
+	}
+	return tag_str
+}

plugins/serializers/graphite/graphite_test.go

@@ -0,0 +1,121 @@
+package graphite
+
+import (
+	"fmt"
+	"sort"
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/assert"
+
+	"github.com/influxdata/telegraf"
+)
+
+func TestGraphiteTags(t *testing.T) {
+	m1, _ := telegraf.NewMetric(
+		"mymeasurement",
+		map[string]string{"host": "192.168.0.1"},
+		map[string]interface{}{"value": float64(3.14)},
+		time.Date(2010, time.November, 10, 23, 0, 0, 0, time.UTC),
+	)
+	m2, _ := telegraf.NewMetric(
+		"mymeasurement",
+		map[string]string{"host": "192.168.0.1", "afoo": "first", "bfoo": "second"},
+		map[string]interface{}{"value": float64(3.14)},
+		time.Date(2010, time.November, 10, 23, 0, 0, 0, time.UTC),
+	)
+	m3, _ := telegraf.NewMetric(
+		"mymeasurement",
+		map[string]string{"afoo": "first", "bfoo": "second"},
+		map[string]interface{}{"value": float64(3.14)},
+		time.Date(2010, time.November, 10, 23, 0, 0, 0, time.UTC),
+	)
+
+	tags1 := buildTags(m1)
+	tags2 := buildTags(m2)
+	tags3 := buildTags(m3)
+
+	assert.Equal(t, "192_168_0_1", tags1)
+	assert.Equal(t, "192_168_0_1.first.second", tags2)
+	assert.Equal(t, "first.second", tags3)
+}
+
+func TestSerializeMetricNoHost(t *testing.T) {
+	now := time.Now()
+	tags := map[string]string{
+		"cpu":        "cpu0",
+		"datacenter": "us-west-2",
+	}
+	fields := map[string]interface{}{
+		"usage_idle": float64(91.5),
+		"usage_busy": float64(8.5),
+	}
+	m, err := telegraf.NewMetric("cpu", tags, fields, now)
+	assert.NoError(t, err)
+
+	s := GraphiteSerializer{}
+	mS, err := s.Serialize(m)
+	assert.NoError(t, err)
+
+	expS := []string{
+		fmt.Sprintf("cpu0.us-west-2.cpu.usage_idle 91.5 %d", now.Unix()),
+		fmt.Sprintf("cpu0.us-west-2.cpu.usage_busy 8.5 %d", now.Unix()),
+	}
+	sort.Strings(mS)
+	sort.Strings(expS)
+	assert.Equal(t, expS, mS)
+}
+
+func TestSerializeMetricHost(t *testing.T) {
+	now := time.Now()
+	tags := map[string]string{
+		"host":       "localhost",
+		"cpu":        "cpu0",
+		"datacenter": "us-west-2",
+	}
+	fields := map[string]interface{}{
+		"usage_idle": float64(91.5),
+		"usage_busy": float64(8.5),
+	}
+	m, err := telegraf.NewMetric("cpu", tags, fields, now)
+	assert.NoError(t, err)
+
+	s := GraphiteSerializer{}
+	mS, err := s.Serialize(m)
+	assert.NoError(t, err)
+
+	expS := []string{
+		fmt.Sprintf("localhost.cpu0.us-west-2.cpu.usage_idle 91.5 %d", now.Unix()),
+		fmt.Sprintf("localhost.cpu0.us-west-2.cpu.usage_busy 8.5 %d", now.Unix()),
+	}
+	sort.Strings(mS)
+	sort.Strings(expS)
+	assert.Equal(t, expS, mS)
+}
+
+func TestSerializeMetricPrefix(t *testing.T) {
+	now := time.Now()
+	tags := map[string]string{
+		"host":       "localhost",
+		"cpu":        "cpu0",
+		"datacenter": "us-west-2",
+	}
+	fields := map[string]interface{}{
+		"usage_idle": float64(91.5),
+		"usage_busy": float64(8.5),
+	}
+	m, err := telegraf.NewMetric("cpu", tags, fields, now)
+	assert.NoError(t, err)
+
+	s := GraphiteSerializer{Prefix: "prefix"}
+	mS, err := s.Serialize(m)
+	assert.NoError(t, err)
+
+	expS := []string{
+		fmt.Sprintf("prefix.localhost.cpu0.us-west-2.cpu.usage_idle 91.5 %d", now.Unix()),
+		fmt.Sprintf("prefix.localhost.cpu0.us-west-2.cpu.usage_busy 8.5 %d", now.Unix()),
+	}
+	sort.Strings(mS)
+	sort.Strings(expS)
+	assert.Equal(t, expS, mS)
+}

plugins/serializers/influx/influx.go

@@ -0,0 +1,12 @@
+package influx
+
+import (
+	"github.com/influxdata/telegraf"
+)
+
+type InfluxSerializer struct {
+}
+
+func (s *InfluxSerializer) Serialize(metric telegraf.Metric) ([]string, error) {
+	return []string{metric.String()}, nil
+}

plugins/serializers/influx/influx_test.go

@@ -0,0 +1,68 @@
+package influx
+
+import (
+	"fmt"
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/assert"
+
+	"github.com/influxdata/telegraf"
+)
+
+func TestSerializeMetricFloat(t *testing.T) {
+	now := time.Now()
+	tags := map[string]string{
+		"cpu": "cpu0",
+	}
+	fields := map[string]interface{}{
+		"usage_idle": float64(91.5),
+	}
+	m, err := telegraf.NewMetric("cpu", tags, fields, now)
+	assert.NoError(t, err)
+
+	s := InfluxSerializer{}
+	mS, err := s.Serialize(m)
+	assert.NoError(t, err)
+
+	expS := []string{fmt.Sprintf("cpu,cpu=cpu0 usage_idle=91.5 %d", now.UnixNano())}
+	assert.Equal(t, expS, mS)
+}
+
+func TestSerializeMetricInt(t *testing.T) {
+	now := time.Now()
+	tags := map[string]string{
+		"cpu": "cpu0",
+	}
+	fields := map[string]interface{}{
+		"usage_idle": int64(90),
+	}
+	m, err := telegraf.NewMetric("cpu", tags, fields, now)
+	assert.NoError(t, err)
+
+	s := InfluxSerializer{}
+	mS, err := s.Serialize(m)
+	assert.NoError(t, err)
+
+	expS := []string{fmt.Sprintf("cpu,cpu=cpu0 usage_idle=90i %d", now.UnixNano())}
+	assert.Equal(t, expS, mS)
+}
+
+func TestSerializeMetricString(t *testing.T) {
+	now := time.Now()
+	tags := map[string]string{
+		"cpu": "cpu0",
+	}
+	fields := map[string]interface{}{
+		"usage_idle": "foobar",
+	}
+	m, err := telegraf.NewMetric("cpu", tags, fields, now)
+	assert.NoError(t, err)
+
+	s := InfluxSerializer{}
+	mS, err := s.Serialize(m)
+	assert.NoError(t, err)
+
+	expS := []string{fmt.Sprintf("cpu,cpu=cpu0 usage_idle=\"foobar\" %d", now.UnixNano())}
+	assert.Equal(t, expS, mS)
+}

plugins/serializers/registry.go

@@ -0,0 +1,55 @@
+package serializers
+
+import (
+	"github.com/influxdata/telegraf"
+
+	"github.com/influxdata/telegraf/plugins/serializers/graphite"
+	"github.com/influxdata/telegraf/plugins/serializers/influx"
+)
+
+// SerializerOutput is an interface for output plugins that are able to
+// serialize telegraf metrics into arbitrary data formats.
+type SerializerOutput interface {
+	// SetSerializer sets the serializer function for the interface.
+	SetSerializer(serializer Serializer)
+}
+
+// Serializer is an interface defining functions that a serializer plugin must
+// satisfy.
+type Serializer interface {
+	// Serialize takes a single telegraf metric and turns it into a string.
+	Serialize(metric telegraf.Metric) ([]string, error)
+}
+
+// Config is a struct that covers the data types needed for all serializer types,
+// and can be used to instantiate _any_ of the serializers.
+type Config struct {
+	// Dataformat can be one of: influx, graphite
+	DataFormat string
+
+	// Prefix to add to all measurements, only supports Graphite
+	Prefix string
+}
+
+// NewSerializer a Serializer interface based on the given config.
+func NewSerializer(config *Config) (Serializer, error) {
+	var err error
+	var serializer Serializer
+	switch config.DataFormat {
+	case "influx":
+		serializer, err = NewInfluxSerializer()
+	case "graphite":
+		serializer, err = NewGraphiteSerializer(config.Prefix)
+	}
+	return serializer, err
+}
+
+func NewInfluxSerializer() (Serializer, error) {
+	return &influx.InfluxSerializer{}, nil
+}
+
+func NewGraphiteSerializer(prefix string) (Serializer, error) {
+	return &graphite.GraphiteSerializer{
+		Prefix: prefix,
+	}, nil
+}