1056 lines
27 KiB
Go
1056 lines
27 KiB
Go
package graphite
|
|
|
|
import (
|
|
"fmt"
|
|
"sort"
|
|
"strings"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/stretchr/testify/assert"
|
|
"github.com/stretchr/testify/require"
|
|
|
|
"github.com/influxdata/telegraf"
|
|
"github.com/influxdata/telegraf/metric"
|
|
)
|
|
|
|
var defaultTags = map[string]string{
|
|
"host": "localhost",
|
|
"cpu": "cpu0",
|
|
"datacenter": "us-west-2",
|
|
}
|
|
|
|
const (
|
|
template1 = "tags.measurement.field"
|
|
template2 = "host.measurement.field"
|
|
template3 = "host.tags.field"
|
|
template4 = "host.tags.measurement"
|
|
// this template explicitly uses all tag keys, so "tags" should be empty
|
|
template5 = "host.datacenter.cpu.tags.measurement.field"
|
|
// this template has non-existent tag keys
|
|
template6 = "foo.host.cpu.bar.tags.measurement.field"
|
|
)
|
|
|
|
func TestGraphiteTags(t *testing.T) {
|
|
m1, _ := metric.New(
|
|
"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, _ := metric.New(
|
|
"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, _ := metric.New(
|
|
"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.Tags())
|
|
tags2 := buildTags(m2.Tags())
|
|
tags3 := buildTags(m3.Tags())
|
|
|
|
assert.Equal(t, "192_168_0_1", tags1)
|
|
assert.Equal(t, "first.second.192_168_0_1", 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 := metric.New("cpu", tags, fields, now)
|
|
assert.NoError(t, err)
|
|
|
|
s := GraphiteSerializer{}
|
|
buf, _ := s.Serialize(m)
|
|
mS := strings.Split(strings.TrimSpace(string(buf)), "\n")
|
|
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 TestSerializeMetricNoHostWithTagSupport(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 := metric.New("cpu", tags, fields, now)
|
|
assert.NoError(t, err)
|
|
|
|
s := GraphiteSerializer{
|
|
TagSupport: true,
|
|
Separator: ".",
|
|
}
|
|
buf, _ := s.Serialize(m)
|
|
mS := strings.Split(strings.TrimSpace(string(buf)), "\n")
|
|
assert.NoError(t, err)
|
|
|
|
expS := []string{
|
|
fmt.Sprintf("cpu.usage_idle;cpu=cpu0;datacenter=us-west-2 91.5 %d", now.Unix()),
|
|
fmt.Sprintf("cpu.usage_busy;cpu=cpu0;datacenter=us-west-2 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 := metric.New("cpu", tags, fields, now)
|
|
assert.NoError(t, err)
|
|
|
|
s := GraphiteSerializer{}
|
|
buf, _ := s.Serialize(m)
|
|
mS := strings.Split(strings.TrimSpace(string(buf)), "\n")
|
|
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 TestSerializeMetricHostWithMultipleTemplates(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),
|
|
}
|
|
m1, err := metric.New("cpu", tags, fields, now)
|
|
m2, err := metric.New("new_cpu", tags, fields, now)
|
|
assert.NoError(t, err)
|
|
|
|
templates, defaultTemplate, err := InitGraphiteTemplates([]string{
|
|
"cp* tags.measurement.host.field",
|
|
"new_cpu tags.host.measurement.field",
|
|
})
|
|
assert.NoError(t, err)
|
|
assert.Equal(t, defaultTemplate, "")
|
|
|
|
s := GraphiteSerializer{
|
|
Templates: templates,
|
|
}
|
|
|
|
buf, _ := s.Serialize(m1)
|
|
buf2, _ := s.Serialize(m2)
|
|
|
|
buf = append(buf, buf2...)
|
|
|
|
mS := strings.Split(strings.TrimSpace(string(buf)), "\n")
|
|
assert.NoError(t, err)
|
|
|
|
expS := []string{
|
|
fmt.Sprintf("cpu0.us-west-2.cpu.localhost.usage_idle 91.5 %d", now.Unix()),
|
|
fmt.Sprintf("cpu0.us-west-2.cpu.localhost.usage_busy 8.5 %d", now.Unix()),
|
|
fmt.Sprintf("cpu0.us-west-2.localhost.new_cpu.usage_idle 91.5 %d", now.Unix()),
|
|
fmt.Sprintf("cpu0.us-west-2.localhost.new_cpu.usage_busy 8.5 %d", now.Unix()),
|
|
}
|
|
sort.Strings(mS)
|
|
sort.Strings(expS)
|
|
assert.Equal(t, expS, mS)
|
|
}
|
|
|
|
func TestSerializeMetricHostWithMultipleTemplatesWithDefault(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),
|
|
}
|
|
m1, err := metric.New("cpu", tags, fields, now)
|
|
m2, err := metric.New("new_cpu", tags, fields, now)
|
|
assert.NoError(t, err)
|
|
|
|
templates, defaultTemplate, err := InitGraphiteTemplates([]string{
|
|
"cp* tags.measurement.host.field",
|
|
"tags.host.measurement.field",
|
|
})
|
|
assert.NoError(t, err)
|
|
assert.Equal(t, defaultTemplate, "tags.host.measurement.field")
|
|
|
|
s := GraphiteSerializer{
|
|
Templates: templates,
|
|
Template: defaultTemplate,
|
|
}
|
|
|
|
buf, _ := s.Serialize(m1)
|
|
buf2, _ := s.Serialize(m2)
|
|
|
|
buf = append(buf, buf2...)
|
|
|
|
mS := strings.Split(strings.TrimSpace(string(buf)), "\n")
|
|
assert.NoError(t, err)
|
|
|
|
expS := []string{
|
|
fmt.Sprintf("cpu0.us-west-2.cpu.localhost.usage_idle 91.5 %d", now.Unix()),
|
|
fmt.Sprintf("cpu0.us-west-2.cpu.localhost.usage_busy 8.5 %d", now.Unix()),
|
|
fmt.Sprintf("cpu0.us-west-2.localhost.new_cpu.usage_idle 91.5 %d", now.Unix()),
|
|
fmt.Sprintf("cpu0.us-west-2.localhost.new_cpu.usage_busy 8.5 %d", now.Unix()),
|
|
}
|
|
sort.Strings(mS)
|
|
sort.Strings(expS)
|
|
assert.Equal(t, expS, mS)
|
|
}
|
|
|
|
func TestSerializeMetricHostWithTagSupport(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 := metric.New("cpu", tags, fields, now)
|
|
assert.NoError(t, err)
|
|
|
|
s := GraphiteSerializer{
|
|
TagSupport: true,
|
|
Separator: ".",
|
|
}
|
|
buf, _ := s.Serialize(m)
|
|
mS := strings.Split(strings.TrimSpace(string(buf)), "\n")
|
|
assert.NoError(t, err)
|
|
|
|
expS := []string{
|
|
fmt.Sprintf("cpu.usage_idle;cpu=cpu0;datacenter=us-west-2;host=localhost 91.5 %d", now.Unix()),
|
|
fmt.Sprintf("cpu.usage_busy;cpu=cpu0;datacenter=us-west-2;host=localhost 8.5 %d", now.Unix()),
|
|
}
|
|
sort.Strings(mS)
|
|
sort.Strings(expS)
|
|
assert.Equal(t, expS, mS)
|
|
}
|
|
|
|
// test that a field named "value" gets ignored.
|
|
func TestSerializeValueField(t *testing.T) {
|
|
now := time.Now()
|
|
tags := map[string]string{
|
|
"host": "localhost",
|
|
"cpu": "cpu0",
|
|
"datacenter": "us-west-2",
|
|
}
|
|
fields := map[string]interface{}{
|
|
"value": float64(91.5),
|
|
}
|
|
m, err := metric.New("cpu", tags, fields, now)
|
|
assert.NoError(t, err)
|
|
|
|
s := GraphiteSerializer{}
|
|
buf, _ := s.Serialize(m)
|
|
mS := strings.Split(strings.TrimSpace(string(buf)), "\n")
|
|
assert.NoError(t, err)
|
|
|
|
expS := []string{
|
|
fmt.Sprintf("localhost.cpu0.us-west-2.cpu 91.5 %d", now.Unix()),
|
|
}
|
|
assert.Equal(t, expS, mS)
|
|
}
|
|
|
|
func TestSerializeValueFieldWithTagSupport(t *testing.T) {
|
|
now := time.Now()
|
|
tags := map[string]string{
|
|
"host": "localhost",
|
|
"cpu": "cpu0",
|
|
"datacenter": "us-west-2",
|
|
}
|
|
fields := map[string]interface{}{
|
|
"value": float64(91.5),
|
|
}
|
|
m, err := metric.New("cpu", tags, fields, now)
|
|
assert.NoError(t, err)
|
|
|
|
s := GraphiteSerializer{
|
|
TagSupport: true,
|
|
Separator: ".",
|
|
}
|
|
buf, _ := s.Serialize(m)
|
|
mS := strings.Split(strings.TrimSpace(string(buf)), "\n")
|
|
assert.NoError(t, err)
|
|
|
|
expS := []string{
|
|
fmt.Sprintf("cpu;cpu=cpu0;datacenter=us-west-2;host=localhost 91.5 %d", now.Unix()),
|
|
}
|
|
assert.Equal(t, expS, mS)
|
|
}
|
|
|
|
// test that a field named "value" gets ignored in middle of template.
|
|
func TestSerializeValueField2(t *testing.T) {
|
|
now := time.Now()
|
|
tags := map[string]string{
|
|
"host": "localhost",
|
|
"cpu": "cpu0",
|
|
"datacenter": "us-west-2",
|
|
}
|
|
fields := map[string]interface{}{
|
|
"value": float64(91.5),
|
|
}
|
|
m, err := metric.New("cpu", tags, fields, now)
|
|
assert.NoError(t, err)
|
|
|
|
s := GraphiteSerializer{
|
|
Template: "host.field.tags.measurement",
|
|
}
|
|
buf, _ := s.Serialize(m)
|
|
mS := strings.Split(strings.TrimSpace(string(buf)), "\n")
|
|
assert.NoError(t, err)
|
|
|
|
expS := []string{
|
|
fmt.Sprintf("localhost.cpu0.us-west-2.cpu 91.5 %d", now.Unix()),
|
|
}
|
|
assert.Equal(t, expS, mS)
|
|
}
|
|
|
|
func TestSerializeValueString(t *testing.T) {
|
|
now := time.Now()
|
|
tags := map[string]string{
|
|
"host": "localhost",
|
|
"cpu": "cpu0",
|
|
"datacenter": "us-west-2",
|
|
}
|
|
fields := map[string]interface{}{
|
|
"value": "asdasd",
|
|
}
|
|
m, err := metric.New("cpu", tags, fields, now)
|
|
assert.NoError(t, err)
|
|
|
|
s := GraphiteSerializer{
|
|
Template: "host.field.tags.measurement",
|
|
}
|
|
buf, _ := s.Serialize(m)
|
|
mS := strings.Split(strings.TrimSpace(string(buf)), "\n")
|
|
assert.NoError(t, err)
|
|
assert.Equal(t, "", mS[0])
|
|
}
|
|
|
|
func TestSerializeValueStringWithTagSupport(t *testing.T) {
|
|
now := time.Now()
|
|
tags := map[string]string{
|
|
"host": "localhost",
|
|
"cpu": "cpu0",
|
|
"datacenter": "us-west-2",
|
|
}
|
|
fields := map[string]interface{}{
|
|
"value": "asdasd",
|
|
}
|
|
m, err := metric.New("cpu", tags, fields, now)
|
|
assert.NoError(t, err)
|
|
|
|
s := GraphiteSerializer{
|
|
TagSupport: true,
|
|
Separator: ".",
|
|
}
|
|
buf, _ := s.Serialize(m)
|
|
mS := strings.Split(strings.TrimSpace(string(buf)), "\n")
|
|
assert.NoError(t, err)
|
|
assert.Equal(t, "", mS[0])
|
|
}
|
|
|
|
func TestSerializeValueBoolean(t *testing.T) {
|
|
now := time.Now()
|
|
tags := map[string]string{
|
|
"host": "localhost",
|
|
"cpu": "cpu0",
|
|
"datacenter": "us-west-2",
|
|
}
|
|
fields := map[string]interface{}{
|
|
"enabled": true,
|
|
"disabled": false,
|
|
}
|
|
m, err := metric.New("cpu", tags, fields, now)
|
|
assert.NoError(t, err)
|
|
|
|
s := GraphiteSerializer{
|
|
Template: "host.field.tags.measurement",
|
|
}
|
|
buf, _ := s.Serialize(m)
|
|
mS := strings.Split(strings.TrimSpace(string(buf)), "\n")
|
|
assert.NoError(t, err)
|
|
|
|
expS := []string{
|
|
fmt.Sprintf("localhost.enabled.cpu0.us-west-2.cpu 1 %d", now.Unix()),
|
|
fmt.Sprintf("localhost.disabled.cpu0.us-west-2.cpu 0 %d", now.Unix()),
|
|
}
|
|
sort.Strings(mS)
|
|
sort.Strings(expS)
|
|
assert.Equal(t, expS, mS)
|
|
}
|
|
|
|
func TestSerializeValueBooleanWithTagSupport(t *testing.T) {
|
|
now := time.Now()
|
|
tags := map[string]string{
|
|
"host": "localhost",
|
|
"cpu": "cpu0",
|
|
"datacenter": "us-west-2",
|
|
}
|
|
fields := map[string]interface{}{
|
|
"enabled": true,
|
|
"disabled": false,
|
|
}
|
|
m, err := metric.New("cpu", tags, fields, now)
|
|
assert.NoError(t, err)
|
|
|
|
s := GraphiteSerializer{
|
|
TagSupport: true,
|
|
Separator: ".",
|
|
}
|
|
buf, _ := s.Serialize(m)
|
|
mS := strings.Split(strings.TrimSpace(string(buf)), "\n")
|
|
assert.NoError(t, err)
|
|
|
|
expS := []string{
|
|
fmt.Sprintf("cpu.enabled;cpu=cpu0;datacenter=us-west-2;host=localhost 1 %d", now.Unix()),
|
|
fmt.Sprintf("cpu.disabled;cpu=cpu0;datacenter=us-west-2;host=localhost 0 %d", now.Unix()),
|
|
}
|
|
sort.Strings(mS)
|
|
sort.Strings(expS)
|
|
assert.Equal(t, expS, mS)
|
|
}
|
|
|
|
func TestSerializeValueUnsigned(t *testing.T) {
|
|
now := time.Unix(0, 0)
|
|
tags := map[string]string{}
|
|
fields := map[string]interface{}{
|
|
"free": uint64(42),
|
|
}
|
|
m, err := metric.New("mem", tags, fields, now)
|
|
require.NoError(t, err)
|
|
|
|
s := GraphiteSerializer{}
|
|
buf, err := s.Serialize(m)
|
|
require.NoError(t, err)
|
|
|
|
require.Equal(t, buf, []byte(".mem.free 42 0\n"))
|
|
}
|
|
|
|
// test that fields with spaces get fixed.
|
|
func TestSerializeFieldWithSpaces(t *testing.T) {
|
|
now := time.Now()
|
|
tags := map[string]string{
|
|
"host": "localhost",
|
|
"cpu": "cpu0",
|
|
"datacenter": "us-west-2",
|
|
}
|
|
fields := map[string]interface{}{
|
|
`field\ with\ spaces`: float64(91.5),
|
|
}
|
|
m, err := metric.New("cpu", tags, fields, now)
|
|
assert.NoError(t, err)
|
|
|
|
s := GraphiteSerializer{
|
|
Template: "host.tags.measurement.field",
|
|
}
|
|
buf, _ := s.Serialize(m)
|
|
mS := strings.Split(strings.TrimSpace(string(buf)), "\n")
|
|
assert.NoError(t, err)
|
|
|
|
expS := []string{
|
|
fmt.Sprintf("localhost.cpu0.us-west-2.cpu.field_with_spaces 91.5 %d", now.Unix()),
|
|
}
|
|
assert.Equal(t, expS, mS)
|
|
}
|
|
|
|
func TestSerializeFieldWithSpacesWithTagSupport(t *testing.T) {
|
|
now := time.Now()
|
|
tags := map[string]string{
|
|
"host": "localhost",
|
|
"cpu": "cpu0",
|
|
"datacenter": "us-west-2",
|
|
}
|
|
fields := map[string]interface{}{
|
|
`field\ with\ spaces`: float64(91.5),
|
|
}
|
|
m, err := metric.New("cpu", tags, fields, now)
|
|
assert.NoError(t, err)
|
|
|
|
s := GraphiteSerializer{
|
|
TagSupport: true,
|
|
Separator: ".",
|
|
}
|
|
buf, _ := s.Serialize(m)
|
|
mS := strings.Split(strings.TrimSpace(string(buf)), "\n")
|
|
assert.NoError(t, err)
|
|
|
|
expS := []string{
|
|
fmt.Sprintf("cpu.field_with_spaces;cpu=cpu0;datacenter=us-west-2;host=localhost 91.5 %d", now.Unix()),
|
|
}
|
|
assert.Equal(t, expS, mS)
|
|
}
|
|
|
|
// test that tags with spaces get fixed.
|
|
func TestSerializeTagWithSpaces(t *testing.T) {
|
|
now := time.Now()
|
|
tags := map[string]string{
|
|
"host": "localhost",
|
|
"cpu": `cpu\ 0`,
|
|
"datacenter": "us-west-2",
|
|
}
|
|
fields := map[string]interface{}{
|
|
`field_with_spaces`: float64(91.5),
|
|
}
|
|
m, err := metric.New("cpu", tags, fields, now)
|
|
assert.NoError(t, err)
|
|
|
|
s := GraphiteSerializer{
|
|
Template: "host.tags.measurement.field",
|
|
}
|
|
buf, _ := s.Serialize(m)
|
|
mS := strings.Split(strings.TrimSpace(string(buf)), "\n")
|
|
assert.NoError(t, err)
|
|
|
|
expS := []string{
|
|
fmt.Sprintf("localhost.cpu_0.us-west-2.cpu.field_with_spaces 91.5 %d", now.Unix()),
|
|
}
|
|
assert.Equal(t, expS, mS)
|
|
}
|
|
|
|
func TestSerializeTagWithSpacesWithTagSupport(t *testing.T) {
|
|
now := time.Now()
|
|
tags := map[string]string{
|
|
"host": "localhost",
|
|
"cpu": `cpu\ 0`,
|
|
"datacenter": "us-west-2",
|
|
}
|
|
fields := map[string]interface{}{
|
|
`field_with_spaces`: float64(91.5),
|
|
}
|
|
m, err := metric.New("cpu", tags, fields, now)
|
|
assert.NoError(t, err)
|
|
|
|
s := GraphiteSerializer{
|
|
TagSupport: true,
|
|
Separator: ".",
|
|
}
|
|
buf, _ := s.Serialize(m)
|
|
mS := strings.Split(strings.TrimSpace(string(buf)), "\n")
|
|
assert.NoError(t, err)
|
|
|
|
expS := []string{
|
|
fmt.Sprintf("cpu.field_with_spaces;cpu=cpu_0;datacenter=us-west-2;host=localhost 91.5 %d", now.Unix()),
|
|
}
|
|
assert.Equal(t, expS, mS)
|
|
}
|
|
|
|
// test that a field named "value" gets ignored at beginning of template.
|
|
func TestSerializeValueField3(t *testing.T) {
|
|
now := time.Now()
|
|
tags := map[string]string{
|
|
"host": "localhost",
|
|
"cpu": "cpu0",
|
|
"datacenter": "us-west-2",
|
|
}
|
|
fields := map[string]interface{}{
|
|
"value": float64(91.5),
|
|
}
|
|
m, err := metric.New("cpu", tags, fields, now)
|
|
assert.NoError(t, err)
|
|
|
|
s := GraphiteSerializer{
|
|
Template: "field.host.tags.measurement",
|
|
}
|
|
buf, _ := s.Serialize(m)
|
|
mS := strings.Split(strings.TrimSpace(string(buf)), "\n")
|
|
assert.NoError(t, err)
|
|
|
|
expS := []string{
|
|
fmt.Sprintf("localhost.cpu0.us-west-2.cpu 91.5 %d", now.Unix()),
|
|
}
|
|
assert.Equal(t, expS, mS)
|
|
}
|
|
|
|
// test that a field named "value" gets ignored at beginning of template.
|
|
func TestSerializeValueField5(t *testing.T) {
|
|
now := time.Now()
|
|
tags := map[string]string{
|
|
"host": "localhost",
|
|
"cpu": "cpu0",
|
|
"datacenter": "us-west-2",
|
|
}
|
|
fields := map[string]interface{}{
|
|
"value": float64(91.5),
|
|
}
|
|
m, err := metric.New("cpu", tags, fields, now)
|
|
assert.NoError(t, err)
|
|
|
|
s := GraphiteSerializer{
|
|
Template: template5,
|
|
}
|
|
buf, _ := s.Serialize(m)
|
|
mS := strings.Split(strings.TrimSpace(string(buf)), "\n")
|
|
assert.NoError(t, err)
|
|
|
|
expS := []string{
|
|
fmt.Sprintf("localhost.us-west-2.cpu0.cpu 91.5 %d", now.Unix()),
|
|
}
|
|
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 := metric.New("cpu", tags, fields, now)
|
|
assert.NoError(t, err)
|
|
|
|
s := GraphiteSerializer{Prefix: "prefix"}
|
|
buf, _ := s.Serialize(m)
|
|
mS := strings.Split(strings.TrimSpace(string(buf)), "\n")
|
|
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)
|
|
}
|
|
|
|
func TestSerializeMetricPrefixWithTagSupport(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 := metric.New("cpu", tags, fields, now)
|
|
assert.NoError(t, err)
|
|
|
|
s := GraphiteSerializer{
|
|
Prefix: "prefix",
|
|
TagSupport: true,
|
|
Separator: ".",
|
|
}
|
|
buf, _ := s.Serialize(m)
|
|
mS := strings.Split(strings.TrimSpace(string(buf)), "\n")
|
|
assert.NoError(t, err)
|
|
|
|
expS := []string{
|
|
fmt.Sprintf("prefix.cpu.usage_idle;cpu=cpu0;datacenter=us-west-2;host=localhost 91.5 %d", now.Unix()),
|
|
fmt.Sprintf("prefix.cpu.usage_busy;cpu=cpu0;datacenter=us-west-2;host=localhost 8.5 %d", now.Unix()),
|
|
}
|
|
sort.Strings(mS)
|
|
sort.Strings(expS)
|
|
assert.Equal(t, expS, mS)
|
|
}
|
|
|
|
func TestSerializeBucketNameNoHost(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),
|
|
}
|
|
m, err := metric.New("cpu", tags, fields, now)
|
|
assert.NoError(t, err)
|
|
|
|
mS := SerializeBucketName(m.Name(), m.Tags(), "", "")
|
|
|
|
expS := "cpu0.us-west-2.cpu.FIELDNAME"
|
|
assert.Equal(t, expS, mS)
|
|
}
|
|
|
|
func TestSerializeBucketNameHost(t *testing.T) {
|
|
now := time.Now()
|
|
fields := map[string]interface{}{
|
|
"usage_idle": float64(91.5),
|
|
}
|
|
m, err := metric.New("cpu", defaultTags, fields, now)
|
|
assert.NoError(t, err)
|
|
|
|
mS := SerializeBucketName(m.Name(), m.Tags(), "", "")
|
|
|
|
expS := "localhost.cpu0.us-west-2.cpu.FIELDNAME"
|
|
assert.Equal(t, expS, mS)
|
|
}
|
|
|
|
func TestSerializeBucketNamePrefix(t *testing.T) {
|
|
now := time.Now()
|
|
fields := map[string]interface{}{
|
|
"usage_idle": float64(91.5),
|
|
}
|
|
m, err := metric.New("cpu", defaultTags, fields, now)
|
|
assert.NoError(t, err)
|
|
|
|
mS := SerializeBucketName(m.Name(), m.Tags(), "", "prefix")
|
|
|
|
expS := "prefix.localhost.cpu0.us-west-2.cpu.FIELDNAME"
|
|
assert.Equal(t, expS, mS)
|
|
}
|
|
|
|
func TestTemplate1(t *testing.T) {
|
|
now := time.Now()
|
|
fields := map[string]interface{}{
|
|
"usage_idle": float64(91.5),
|
|
}
|
|
m, err := metric.New("cpu", defaultTags, fields, now)
|
|
assert.NoError(t, err)
|
|
|
|
mS := SerializeBucketName(m.Name(), m.Tags(), template1, "")
|
|
|
|
expS := "cpu0.us-west-2.localhost.cpu.FIELDNAME"
|
|
assert.Equal(t, expS, mS)
|
|
}
|
|
|
|
func TestTemplate2(t *testing.T) {
|
|
now := time.Now()
|
|
fields := map[string]interface{}{
|
|
"usage_idle": float64(91.5),
|
|
}
|
|
m, err := metric.New("cpu", defaultTags, fields, now)
|
|
assert.NoError(t, err)
|
|
|
|
mS := SerializeBucketName(m.Name(), m.Tags(), template2, "")
|
|
|
|
expS := "localhost.cpu.FIELDNAME"
|
|
assert.Equal(t, expS, mS)
|
|
}
|
|
|
|
func TestTemplate3(t *testing.T) {
|
|
now := time.Now()
|
|
fields := map[string]interface{}{
|
|
"usage_idle": float64(91.5),
|
|
}
|
|
m, err := metric.New("cpu", defaultTags, fields, now)
|
|
assert.NoError(t, err)
|
|
|
|
mS := SerializeBucketName(m.Name(), m.Tags(), template3, "")
|
|
|
|
expS := "localhost.cpu0.us-west-2.FIELDNAME"
|
|
assert.Equal(t, expS, mS)
|
|
}
|
|
|
|
func TestTemplate4(t *testing.T) {
|
|
now := time.Now()
|
|
fields := map[string]interface{}{
|
|
"usage_idle": float64(91.5),
|
|
}
|
|
m, err := metric.New("cpu", defaultTags, fields, now)
|
|
assert.NoError(t, err)
|
|
|
|
mS := SerializeBucketName(m.Name(), m.Tags(), template4, "")
|
|
|
|
expS := "localhost.cpu0.us-west-2.cpu"
|
|
assert.Equal(t, expS, mS)
|
|
}
|
|
|
|
func TestTemplate6(t *testing.T) {
|
|
now := time.Now()
|
|
fields := map[string]interface{}{
|
|
"usage_idle": float64(91.5),
|
|
}
|
|
m, err := metric.New("cpu", defaultTags, fields, now)
|
|
assert.NoError(t, err)
|
|
|
|
mS := SerializeBucketName(m.Name(), m.Tags(), template6, "")
|
|
|
|
expS := "localhost.cpu0.us-west-2.cpu.FIELDNAME"
|
|
assert.Equal(t, expS, mS)
|
|
}
|
|
|
|
func TestClean(t *testing.T) {
|
|
now := time.Unix(1234567890, 0)
|
|
tests := []struct {
|
|
name string
|
|
metric_name string
|
|
tags map[string]string
|
|
fields map[string]interface{}
|
|
expected string
|
|
}{
|
|
{
|
|
"Base metric",
|
|
"cpu",
|
|
map[string]string{"host": "localhost"},
|
|
map[string]interface{}{"usage_busy": float64(8.5)},
|
|
"localhost.cpu.usage_busy 8.5 1234567890\n",
|
|
},
|
|
{
|
|
"Dot and whitespace in tags",
|
|
"cpu",
|
|
map[string]string{"host": "localhost", "label.dot and space": "value with.dot"},
|
|
map[string]interface{}{"usage_busy": float64(8.5)},
|
|
"localhost.value_with_dot.cpu.usage_busy 8.5 1234567890\n",
|
|
},
|
|
{
|
|
"Field with space",
|
|
"system",
|
|
map[string]string{"host": "localhost"},
|
|
map[string]interface{}{"uptime_format": "20 days, 23:26"},
|
|
"", // yes nothing. graphite don't serialize string fields
|
|
},
|
|
{
|
|
"Allowed punct",
|
|
"cpu",
|
|
map[string]string{"host": "localhost", "tag": "-_:="},
|
|
map[string]interface{}{"usage_busy": float64(10)},
|
|
"localhost.-_:=.cpu.usage_busy 10 1234567890\n",
|
|
},
|
|
{
|
|
"Special conversions to hyphen",
|
|
"cpu",
|
|
map[string]string{"host": "localhost", "tag": "/@*"},
|
|
map[string]interface{}{"usage_busy": float64(10)},
|
|
"localhost.---.cpu.usage_busy 10 1234567890\n",
|
|
},
|
|
{
|
|
"Special drop chars",
|
|
"cpu",
|
|
map[string]string{"host": "localhost", "tag": `\no slash`},
|
|
map[string]interface{}{"usage_busy": float64(10)},
|
|
"localhost.no_slash.cpu.usage_busy 10 1234567890\n",
|
|
},
|
|
{
|
|
"Empty tag & value field",
|
|
"cpu",
|
|
map[string]string{"host": "localhost"},
|
|
map[string]interface{}{"value": float64(10)},
|
|
"localhost.cpu 10 1234567890\n",
|
|
},
|
|
{
|
|
"Unicode Letters allowed",
|
|
"cpu",
|
|
map[string]string{"host": "localhost", "tag": "μnicodε_letters"},
|
|
map[string]interface{}{"value": float64(10)},
|
|
"localhost.μnicodε_letters.cpu 10 1234567890\n",
|
|
},
|
|
{
|
|
"Other Unicode not allowed",
|
|
"cpu",
|
|
map[string]string{"host": "localhost", "tag": "“☢”"},
|
|
map[string]interface{}{"value": float64(10)},
|
|
"localhost.___.cpu 10 1234567890\n",
|
|
},
|
|
{
|
|
"Newline in tags",
|
|
"cpu",
|
|
map[string]string{"host": "localhost", "label": "some\nthing\nwith\nnewline"},
|
|
map[string]interface{}{"usage_busy": float64(8.5)},
|
|
"localhost.some_thing_with_newline.cpu.usage_busy 8.5 1234567890\n",
|
|
},
|
|
}
|
|
|
|
s := GraphiteSerializer{}
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
m, err := metric.New(tt.metric_name, tt.tags, tt.fields, now)
|
|
assert.NoError(t, err)
|
|
actual, _ := s.Serialize(m)
|
|
require.Equal(t, tt.expected, string(actual))
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestCleanWithTagsSupport(t *testing.T) {
|
|
now := time.Unix(1234567890, 0)
|
|
tests := []struct {
|
|
name string
|
|
metric_name string
|
|
tags map[string]string
|
|
fields map[string]interface{}
|
|
expected string
|
|
}{
|
|
{
|
|
"Base metric",
|
|
"cpu",
|
|
map[string]string{"host": "localhost"},
|
|
map[string]interface{}{"usage_busy": float64(8.5)},
|
|
"cpu.usage_busy;host=localhost 8.5 1234567890\n",
|
|
},
|
|
{
|
|
"Dot and whitespace in tags",
|
|
"cpu",
|
|
map[string]string{"host": "localhost", "label.dot and space": "value with.dot"},
|
|
map[string]interface{}{"usage_busy": float64(8.5)},
|
|
"cpu.usage_busy;host=localhost;label.dot_and_space=value_with.dot 8.5 1234567890\n",
|
|
},
|
|
{
|
|
"Field with space",
|
|
"system",
|
|
map[string]string{"host": "localhost"},
|
|
map[string]interface{}{"uptime_format": "20 days, 23:26"},
|
|
"", // yes nothing. graphite don't serialize string fields
|
|
},
|
|
{
|
|
"Allowed punct",
|
|
"cpu",
|
|
map[string]string{"host": "localhost", "tag": "-_:="},
|
|
map[string]interface{}{"usage_busy": float64(10)},
|
|
"cpu.usage_busy;host=localhost;tag=-_:= 10 1234567890\n",
|
|
},
|
|
{
|
|
"Special conversions to hyphen",
|
|
"cpu",
|
|
map[string]string{"host": "localhost", "tag": "/@*"},
|
|
map[string]interface{}{"usage_busy": float64(10)},
|
|
"cpu.usage_busy;host=localhost;tag=--- 10 1234567890\n",
|
|
},
|
|
{
|
|
"Special drop chars",
|
|
"cpu",
|
|
map[string]string{"host": "localhost", "tag": `\no slash`},
|
|
map[string]interface{}{"usage_busy": float64(10)},
|
|
"cpu.usage_busy;host=localhost;tag=no_slash 10 1234567890\n",
|
|
},
|
|
{
|
|
"Empty tag & value field",
|
|
"cpu",
|
|
map[string]string{"host": "localhost"},
|
|
map[string]interface{}{"value": float64(10)},
|
|
"cpu;host=localhost 10 1234567890\n",
|
|
},
|
|
{
|
|
"Unicode Letters allowed",
|
|
"cpu",
|
|
map[string]string{"host": "localhost", "tag": "μnicodε_letters"},
|
|
map[string]interface{}{"value": float64(10)},
|
|
"cpu;host=localhost;tag=μnicodε_letters 10 1234567890\n",
|
|
},
|
|
{
|
|
"Other Unicode not allowed",
|
|
"cpu",
|
|
map[string]string{"host": "localhost", "tag": "“☢”"},
|
|
map[string]interface{}{"value": float64(10)},
|
|
"cpu;host=localhost;tag=___ 10 1234567890\n",
|
|
},
|
|
{
|
|
"Newline in tags",
|
|
"cpu",
|
|
map[string]string{"host": "localhost", "label": "some\nthing\nwith\nnewline"},
|
|
map[string]interface{}{"usage_busy": float64(8.5)},
|
|
"cpu.usage_busy;host=localhost;label=some_thing_with_newline 8.5 1234567890\n",
|
|
},
|
|
}
|
|
|
|
s := GraphiteSerializer{
|
|
TagSupport: true,
|
|
Separator: ".",
|
|
}
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
m, err := metric.New(tt.metric_name, tt.tags, tt.fields, now)
|
|
assert.NoError(t, err)
|
|
actual, _ := s.Serialize(m)
|
|
require.Equal(t, tt.expected, string(actual))
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestSerializeBatch(t *testing.T) {
|
|
now := time.Unix(1234567890, 0)
|
|
tests := []struct {
|
|
name string
|
|
metric_name string
|
|
tags map[string]string
|
|
fields map[string]interface{}
|
|
expected string
|
|
}{
|
|
{
|
|
"Base metric",
|
|
"cpu",
|
|
map[string]string{"host": "localhost"},
|
|
map[string]interface{}{"usage_busy": float64(8.5)},
|
|
"localhost.cpu.usage_busy 8.5 1234567890\nlocalhost.cpu.usage_busy 8.5 1234567890\n",
|
|
},
|
|
}
|
|
|
|
s := GraphiteSerializer{}
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
m, err := metric.New(tt.metric_name, tt.tags, tt.fields, now)
|
|
assert.NoError(t, err)
|
|
actual, _ := s.SerializeBatch([]telegraf.Metric{m, m})
|
|
require.Equal(t, tt.expected, string(actual))
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestSerializeBatchWithTagsSupport(t *testing.T) {
|
|
now := time.Unix(1234567890, 0)
|
|
tests := []struct {
|
|
name string
|
|
metric_name string
|
|
tags map[string]string
|
|
fields map[string]interface{}
|
|
expected string
|
|
}{
|
|
{
|
|
"Base metric",
|
|
"cpu",
|
|
map[string]string{"host": "localhost"},
|
|
map[string]interface{}{"usage_busy": float64(8.5)},
|
|
"cpu.usage_busy;host=localhost 8.5 1234567890\ncpu.usage_busy;host=localhost 8.5 1234567890\n",
|
|
},
|
|
}
|
|
|
|
s := GraphiteSerializer{
|
|
TagSupport: true,
|
|
Separator: ".",
|
|
}
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
m, err := metric.New(tt.metric_name, tt.tags, tt.fields, now)
|
|
assert.NoError(t, err)
|
|
actual, _ := s.SerializeBatch([]telegraf.Metric{m, m})
|
|
require.Equal(t, tt.expected, string(actual))
|
|
})
|
|
}
|
|
}
|