telegraf/plugins/serializers/wavefront/wavefront_test.go

341 lines
8.6 KiB
Go
Executable File

package wavefront
import (
"fmt"
"reflect"
"strings"
"testing"
"time"
"github.com/influxdata/telegraf"
"github.com/influxdata/telegraf/metric"
"github.com/influxdata/telegraf/plugins/outputs/wavefront"
"github.com/stretchr/testify/assert"
)
func TestBuildTags(t *testing.T) {
var tagTests = []struct {
ptIn map[string]string
outTags map[string]string
outSource string
}{
{
map[string]string{"one": "two", "three": "four", "host": "testHost"},
map[string]string{"one": "two", "three": "four"},
"testHost",
},
{
map[string]string{"aaa": "bbb", "host": "testHost"},
map[string]string{"aaa": "bbb"},
"testHost",
},
{
map[string]string{"bbb": "789", "aaa": "123", "host": "testHost"},
map[string]string{"aaa": "123", "bbb": "789"},
"testHost",
},
{
map[string]string{"host": "aaa", "dc": "bbb"},
map[string]string{"dc": "bbb"},
"aaa",
},
{
map[string]string{"instanceid": "i-0123456789", "host": "aaa", "dc": "bbb"},
map[string]string{"dc": "bbb", "telegraf_host": "aaa"},
"i-0123456789",
},
{
map[string]string{"instance-id": "i-0123456789", "host": "aaa", "dc": "bbb"},
map[string]string{"dc": "bbb", "telegraf_host": "aaa"},
"i-0123456789",
},
{
map[string]string{"instanceid": "i-0123456789", "host": "aaa", "hostname": "ccc", "dc": "bbb"},
map[string]string{"dc": "bbb", "hostname": "ccc", "telegraf_host": "aaa"},
"i-0123456789",
},
{
map[string]string{"instanceid": "i-0123456789", "host": "aaa", "snmp_host": "ccc", "dc": "bbb"},
map[string]string{"dc": "bbb", "snmp_host": "ccc", "telegraf_host": "aaa"},
"i-0123456789",
},
{
map[string]string{"host": "aaa", "snmp_host": "ccc", "dc": "bbb"},
map[string]string{"dc": "bbb", "telegraf_host": "aaa"},
"ccc",
},
}
s := WavefrontSerializer{SourceOverride: []string{"instanceid", "instance-id", "hostname", "snmp_host", "node_host"}}
for _, tt := range tagTests {
source, tags := buildTags(tt.ptIn, &s)
if !reflect.DeepEqual(tags, tt.outTags) {
t.Errorf("\nexpected\t%+v\nreceived\t%+v\n", tt.outTags, tags)
}
if source != tt.outSource {
t.Errorf("\nexpected\t%s\nreceived\t%s\n", tt.outSource, source)
}
}
}
func TestBuildTagsHostTag(t *testing.T) {
var tagTests = []struct {
ptIn map[string]string
outTags map[string]string
outSource string
}{
{
map[string]string{"one": "two", "host": "testHost", "snmp_host": "snmpHost"},
map[string]string{"telegraf_host": "testHost", "one": "two"},
"snmpHost",
},
}
s := WavefrontSerializer{SourceOverride: []string{"snmp_host"}}
for _, tt := range tagTests {
source, tags := buildTags(tt.ptIn, &s)
if !reflect.DeepEqual(tags, tt.outTags) {
t.Errorf("\nexpected\t%+v\nreceived\t%+v\n", tt.outTags, tags)
}
if source != tt.outSource {
t.Errorf("\nexpected\t%s\nreceived\t%s\n", tt.outSource, source)
}
}
}
func TestFormatMetricPoint(t *testing.T) {
var pointTests = []struct {
ptIn *wavefront.MetricPoint
out string
}{
{
&wavefront.MetricPoint{
Metric: "cpu.idle",
Value: 1,
Timestamp: 1554172967,
Source: "testHost",
Tags: map[string]string{"aaa": "bbb"},
},
"\"cpu.idle\" 1.000000 1554172967 source=\"testHost\" \"aaa\"=\"bbb\"\n",
},
{
&wavefront.MetricPoint{
Metric: "cpu.idle",
Value: 1,
Timestamp: 1554172967,
Source: "testHost",
Tags: map[string]string{"sp&c!al/chars,": "get*replaced"},
},
"\"cpu.idle\" 1.000000 1554172967 source=\"testHost\" \"sp-c-al-chars-\"=\"get-replaced\"\n",
},
}
s := WavefrontSerializer{}
for _, pt := range pointTests {
bout := formatMetricPoint(new(buffer), pt.ptIn, &s)
sout := string(bout[:])
if sout != pt.out {
t.Errorf("\nexpected\t%s\nreceived\t%s\n", pt.out, sout)
}
}
}
func TestUseStrict(t *testing.T) {
var pointTests = []struct {
ptIn *wavefront.MetricPoint
out string
}{
{
&wavefront.MetricPoint{
Metric: "cpu.idle",
Value: 1,
Timestamp: 1554172967,
Source: "testHost",
Tags: map[string]string{"sp&c!al/chars,": "get*replaced"},
},
"\"cpu.idle\" 1.000000 1554172967 source=\"testHost\" \"sp-c-al/chars,\"=\"get-replaced\"\n",
},
}
s := WavefrontSerializer{UseStrict: true}
for _, pt := range pointTests {
bout := formatMetricPoint(new(buffer), pt.ptIn, &s)
sout := string(bout[:])
if sout != pt.out {
t.Errorf("\nexpected\t%s\nreceived\t%s\n", pt.out, sout)
}
}
}
func TestSerializeMetricFloat(t *testing.T) {
now := time.Now()
tags := map[string]string{
"cpu": "cpu0",
"host": "realHost",
}
fields := map[string]interface{}{
"usage_idle": float64(91.5),
}
m, err := metric.New("cpu", tags, fields, now)
assert.NoError(t, err)
s := WavefrontSerializer{}
buf, _ := s.Serialize(m)
mS := strings.Split(strings.TrimSpace(string(buf)), "\n")
assert.NoError(t, err)
expS := []string{fmt.Sprintf("\"cpu.usage.idle\" 91.500000 %d source=\"realHost\" \"cpu\"=\"cpu0\"", now.UnixNano()/1000000000)}
assert.Equal(t, expS, mS)
}
func TestSerializeMetricInt(t *testing.T) {
now := time.Now()
tags := map[string]string{
"cpu": "cpu0",
"host": "realHost",
}
fields := map[string]interface{}{
"usage_idle": int64(91),
}
m, err := metric.New("cpu", tags, fields, now)
assert.NoError(t, err)
s := WavefrontSerializer{}
buf, _ := s.Serialize(m)
mS := strings.Split(strings.TrimSpace(string(buf)), "\n")
assert.NoError(t, err)
expS := []string{fmt.Sprintf("\"cpu.usage.idle\" 91.000000 %d source=\"realHost\" \"cpu\"=\"cpu0\"", now.UnixNano()/1000000000)}
assert.Equal(t, expS, mS)
}
func TestSerializeMetricBoolTrue(t *testing.T) {
now := time.Now()
tags := map[string]string{
"cpu": "cpu0",
"host": "realHost",
}
fields := map[string]interface{}{
"usage_idle": true,
}
m, err := metric.New("cpu", tags, fields, now)
assert.NoError(t, err)
s := WavefrontSerializer{}
buf, _ := s.Serialize(m)
mS := strings.Split(strings.TrimSpace(string(buf)), "\n")
assert.NoError(t, err)
expS := []string{fmt.Sprintf("\"cpu.usage.idle\" 1.000000 %d source=\"realHost\" \"cpu\"=\"cpu0\"", now.UnixNano()/1000000000)}
assert.Equal(t, expS, mS)
}
func TestSerializeMetricBoolFalse(t *testing.T) {
now := time.Now()
tags := map[string]string{
"cpu": "cpu0",
"host": "realHost",
}
fields := map[string]interface{}{
"usage_idle": false,
}
m, err := metric.New("cpu", tags, fields, now)
assert.NoError(t, err)
s := WavefrontSerializer{}
buf, _ := s.Serialize(m)
mS := strings.Split(strings.TrimSpace(string(buf)), "\n")
assert.NoError(t, err)
expS := []string{fmt.Sprintf("\"cpu.usage.idle\" 0.000000 %d source=\"realHost\" \"cpu\"=\"cpu0\"", now.UnixNano()/1000000000)}
assert.Equal(t, expS, mS)
}
func TestSerializeMetricFieldValue(t *testing.T) {
now := time.Now()
tags := map[string]string{
"cpu": "cpu0",
"host": "realHost",
}
fields := map[string]interface{}{
"value": int64(91),
}
m, err := metric.New("cpu", tags, fields, now)
assert.NoError(t, err)
s := WavefrontSerializer{}
buf, _ := s.Serialize(m)
mS := strings.Split(strings.TrimSpace(string(buf)), "\n")
assert.NoError(t, err)
expS := []string{fmt.Sprintf("\"cpu\" 91.000000 %d source=\"realHost\" \"cpu\"=\"cpu0\"", now.UnixNano()/1000000000)}
assert.Equal(t, expS, mS)
}
func TestSerializeMetricPrefix(t *testing.T) {
now := time.Now()
tags := map[string]string{
"cpu": "cpu0",
"host": "realHost",
}
fields := map[string]interface{}{
"usage_idle": int64(91),
}
m, err := metric.New("cpu", tags, fields, now)
assert.NoError(t, err)
s := WavefrontSerializer{Prefix: "telegraf."}
buf, _ := s.Serialize(m)
mS := strings.Split(strings.TrimSpace(string(buf)), "\n")
assert.NoError(t, err)
expS := []string{fmt.Sprintf("\"telegraf.cpu.usage.idle\" 91.000000 %d source=\"realHost\" \"cpu\"=\"cpu0\"", now.UnixNano()/1000000000)}
assert.Equal(t, expS, mS)
}
func benchmarkMetrics(b *testing.B) [4]telegraf.Metric {
b.Helper()
now := time.Now()
tags := map[string]string{
"cpu": "cpu0",
"host": "realHost",
}
newMetric := func(v interface{}) telegraf.Metric {
fields := map[string]interface{}{
"usage_idle": v,
}
m, err := metric.New("cpu", tags, fields, now)
if err != nil {
b.Fatal(err)
}
return m
}
return [4]telegraf.Metric{
newMetric(91.5),
newMetric(91),
newMetric(true),
newMetric(false),
}
}
func BenchmarkSerialize(b *testing.B) {
var s WavefrontSerializer
metrics := benchmarkMetrics(b)
b.ResetTimer()
for i := 0; i < b.N; i++ {
s.Serialize(metrics[i%len(metrics)])
}
}
func BenchmarkSerializeBatch(b *testing.B) {
var s WavefrontSerializer
m := benchmarkMetrics(b)
metrics := m[:]
b.ResetTimer()
for i := 0; i < b.N; i++ {
s.SerializeBatch(metrics)
}
}