dom
/
telegraf
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Add prometheus round trip unit tests (#6720)

This commit is contained in:
Daniel Nelson 2019-11-26 17:31:36 -08:00 committed by GitHub
parent 80c5edd48e
commit 10db774db3
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
13 changed files with 935 additions and 456 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
plugins/inputs/filecount/filecount_test.go
View File

@ -144,6 +144,7 @@ func TestDirectoryWithTrailingSlash(t *testing.T) {
"size_bytes": 5096, "size_bytes": 5096,
}, },
time.Unix(0, 0), time.Unix(0, 0),
telegraf.Gauge,
), ),
} }

2
plugins/inputs/processes/processes_test.go
View File

@ -153,7 +153,7 @@ func TestParkedProcess(t *testing.T) {
"zombies": 0, "zombies": 0,
}, },
time.Unix(0, 0), time.Unix(0, 0),
telegraf.Untyped, telegraf.Gauge,
), ),
} }
actual := acc.GetTelegrafMetrics() actual := acc.GetTelegrafMetrics()

4
plugins/inputs/statsd/statsd_test.go
View File

@ -875,6 +875,7 @@ func TestParse_DataDogTags(t *testing.T) {
"value": 1, "value": 1,
}, },
time.Now(), time.Now(),
telegraf.Counter,
), ),
}, },
}, },
@ -892,6 +893,7 @@ func TestParse_DataDogTags(t *testing.T) {
"value": 10.1, "value": 10.1,
}, },
time.Now(), time.Now(),
telegraf.Gauge,
), ),
}, },
}, },
@ -948,6 +950,7 @@ func TestParse_DataDogTags(t *testing.T) {
"value": 42, "value": 42,
}, },
time.Now(), time.Now(),
telegraf.Counter,
), ),
}, },
}, },
@ -1668,6 +1671,7 @@ func TestTCP(t *testing.T) {
"value": 42, "value": 42,
}, },
time.Now(), time.Now(),
telegraf.Counter,
), ),
}, },
acc.GetTelegrafMetrics(), acc.GetTelegrafMetrics(),

12
plugins/inputs/syslog/commons_test.go
View File

@ -1,10 +1,12 @@
package syslog package syslog
import ( import (
"time"
"github.com/influxdata/telegraf"
"github.com/influxdata/telegraf/internal" "github.com/influxdata/telegraf/internal"
framing "github.com/influxdata/telegraf/internal/syslog" framing "github.com/influxdata/telegraf/internal/syslog"
"github.com/influxdata/telegraf/testutil" "github.com/influxdata/telegraf/testutil"
"time"
) )
var ( var (
@ -14,16 +16,16 @@ var (
type testCasePacket struct { type testCasePacket struct {
name string name string
data []byte data []byte
wantBestEffort *testutil.Metric wantBestEffort telegraf.Metric
wantStrict *testutil.Metric wantStrict telegraf.Metric
werr bool werr bool
} }
type testCaseStream struct { type testCaseStream struct {
name string name string
data []byte data []byte
wantBestEffort []testutil.Metric wantBestEffort []telegraf.Metric
wantStrict []testutil.Metric wantStrict []telegraf.Metric
werr int // how many errors we expect in the strict mode? werr int // how many errors we expect in the strict mode?
} }

125
plugins/inputs/syslog/nontransparent_test.go
View File

@ -9,7 +9,7 @@ import (
"testing" "testing"
"time" "time"
"github.com/google/go-cmp/cmp" "github.com/influxdata/telegraf"
"github.com/influxdata/telegraf/internal" "github.com/influxdata/telegraf/internal"
framing "github.com/influxdata/telegraf/internal/syslog" framing "github.com/influxdata/telegraf/internal/syslog"
"github.com/influxdata/telegraf/testutil" "github.com/influxdata/telegraf/testutil"
@ -21,10 +21,16 @@ func getTestCasesForNonTransparent() []testCaseStream {
{ {
name: "1st/avg/ok", name: "1st/avg/ok",
data: []byte(`<29>1 2016-02-21T04:32:57+00:00 web1 someservice 2341 2 [origin][meta sequence="14125553" service="someservice"] "GET /v1/ok HTTP/1.1" 200 145 "-" "hacheck 0.9.0" 24306 127.0.0.1:40124 575`), data: []byte(`<29>1 2016-02-21T04:32:57+00:00 web1 someservice 2341 2 [origin][meta sequence="14125553" service="someservice"] "GET /v1/ok HTTP/1.1" 200 145 "-" "hacheck 0.9.0" 24306 127.0.0.1:40124 575`),
wantStrict: []testutil.Metric{ wantStrict: []telegraf.Metric{
{ testutil.MustMetric(
Measurement: "syslog", "syslog",
Fields: map[string]interface{}{ map[string]string{
"severity": "notice",
"facility": "daemon",
"hostname": "web1",
"appname": "someservice",
},
map[string]interface{}{
"version": uint16(1), "version": uint16(1),
"timestamp": time.Unix(1456029177, 0).UnixNano(), "timestamp": time.Unix(1456029177, 0).UnixNano(),
"procid": "2341", "procid": "2341",
@ -36,19 +42,19 @@ func getTestCasesForNonTransparent() []testCaseStream {
"severity_code": 5, "severity_code": 5,
"facility_code": 3, "facility_code": 3,
}, },
Tags: map[string]string{ defaultTime,
),
},
wantBestEffort: []telegraf.Metric{
testutil.MustMetric(
"syslog",
map[string]string{
"severity": "notice", "severity": "notice",
"facility": "daemon", "facility": "daemon",
"hostname": "web1", "hostname": "web1",
"appname": "someservice", "appname": "someservice",
}, },
Time: defaultTime, map[string]interface{}{
},
},
wantBestEffort: []testutil.Metric{
{
Measurement: "syslog",
Fields: map[string]interface{}{
"version": uint16(1), "version": uint16(1),
"timestamp": time.Unix(1456029177, 0).UnixNano(), "timestamp": time.Unix(1456029177, 0).UnixNano(),
"procid": "2341", "procid": "2341",
@ -60,75 +66,69 @@ func getTestCasesForNonTransparent() []testCaseStream {
"severity_code": 5, "severity_code": 5,
"facility_code": 3, "facility_code": 3,
}, },
Tags: map[string]string{ defaultTime,
"severity": "notice", ),
"facility": "daemon",
"hostname": "web1",
"appname": "someservice",
},
Time: defaultTime,
},
}, },
werr: 1, werr: 1,
}, },
{ {
name: "1st/min/ok//2nd/min/ok", name: "1st/min/ok//2nd/min/ok",
data: []byte("<1>2 - - - - - -\n<4>11 - - - - - -\n"), data: []byte("<1>2 - - - - - -\n<4>11 - - - - - -\n"),
wantStrict: []testutil.Metric{ wantStrict: []telegraf.Metric{
{ testutil.MustMetric(
Measurement: "syslog", "syslog",
Fields: map[string]interface{}{ map[string]string{
"severity": "alert",
"facility": "kern",
},
map[string]interface{}{
"version": uint16(2), "version": uint16(2),
"severity_code": 1, "severity_code": 1,
"facility_code": 0, "facility_code": 0,
}, },
Tags: map[string]string{ defaultTime,
"severity": "alert", ),
testutil.MustMetric(
"syslog",
map[string]string{
"severity": "warning",
"facility": "kern", "facility": "kern",
}, },
Time: defaultTime, map[string]interface{}{
},
{
Measurement: "syslog",
Fields: map[string]interface{}{
"version": uint16(11), "version": uint16(11),
"severity_code": 4, "severity_code": 4,
"facility_code": 0, "facility_code": 0,
}, },
Tags: map[string]string{ defaultTime.Add(time.Nanosecond),
"severity": "warning", ),
},
wantBestEffort: []telegraf.Metric{
testutil.MustMetric(
"syslog",
map[string]string{
"severity": "alert",
"facility": "kern", "facility": "kern",
}, },
Time: defaultTime.Add(time.Nanosecond), map[string]interface{}{
},
},
wantBestEffort: []testutil.Metric{
{
Measurement: "syslog",
Fields: map[string]interface{}{
"version": uint16(2), "version": uint16(2),
"severity_code": 1, "severity_code": 1,
"facility_code": 0, "facility_code": 0,
}, },
Tags: map[string]string{ defaultTime,
"severity": "alert", ),
testutil.MustMetric(
"syslog",
map[string]string{
"severity": "warning",
"facility": "kern", "facility": "kern",
}, },
Time: defaultTime, map[string]interface{}{
},
{
Measurement: "syslog",
Fields: map[string]interface{}{
"version": uint16(11), "version": uint16(11),
"severity_code": 4, "severity_code": 4,
"facility_code": 0, "facility_code": 0,
}, },
Tags: map[string]string{ defaultTime.Add(time.Nanosecond),
"severity": "warning", ),
"facility": "kern",
},
Time: defaultTime.Add(time.Nanosecond),
},
}, },
}, },
} }
@ -186,13 +186,7 @@ func testStrictNonTransparent(t *testing.T, protocol string, address string, wan
if len(acc.Errors) != tc.werr { if len(acc.Errors) != tc.werr {
t.Fatalf("Got unexpected errors. want error = %v, errors = %v\n", tc.werr, acc.Errors) t.Fatalf("Got unexpected errors. want error = %v, errors = %v\n", tc.werr, acc.Errors)
} }
var got []testutil.Metric testutil.RequireMetricsEqual(t, tc.wantStrict, acc.GetTelegrafMetrics())
for _, metric := range acc.Metrics {
got = append(got, *metric)
}
if !cmp.Equal(tc.wantStrict, got) {
t.Fatalf("Got (+) / Want (-)\n %s", cmp.Diff(tc.wantStrict, got))
}
}) })
} }
} }
@ -240,14 +234,7 @@ func testBestEffortNonTransparent(t *testing.T, protocol string, address string,
acc.Wait(len(tc.wantBestEffort)) acc.Wait(len(tc.wantBestEffort))
} }
// Verify testutil.RequireMetricsEqual(t, tc.wantStrict, acc.GetTelegrafMetrics())
var got []testutil.Metric
for _, metric := range acc.Metrics {
got = append(got, *metric)
}
if !cmp.Equal(tc.wantBestEffort, got) {
t.Fatalf("Got (+) / Want (-)\n %s", cmp.Diff(tc.wantBestEffort, got))
}
}) })
} }
} }

313
plugins/inputs/syslog/octetcounting_test.go
View File

@ -10,7 +10,7 @@ import (
"testing" "testing"
"time" "time"
"github.com/google/go-cmp/cmp" "github.com/influxdata/telegraf"
"github.com/influxdata/telegraf/internal" "github.com/influxdata/telegraf/internal"
framing "github.com/influxdata/telegraf/internal/syslog" framing "github.com/influxdata/telegraf/internal/syslog"
"github.com/influxdata/telegraf/testutil" "github.com/influxdata/telegraf/testutil"
@ -22,10 +22,16 @@ func getTestCasesForOctetCounting() []testCaseStream {
{ {
name: "1st/avg/ok", name: "1st/avg/ok",
data: []byte(`188 <29>1 2016-02-21T04:32:57+00:00 web1 someservice 2341 2 [origin][meta sequence="14125553" service="someservice"] "GET /v1/ok HTTP/1.1" 200 145 "-" "hacheck 0.9.0" 24306 127.0.0.1:40124 575`), data: []byte(`188 <29>1 2016-02-21T04:32:57+00:00 web1 someservice 2341 2 [origin][meta sequence="14125553" service="someservice"] "GET /v1/ok HTTP/1.1" 200 145 "-" "hacheck 0.9.0" 24306 127.0.0.1:40124 575`),
wantStrict: []testutil.Metric{ wantStrict: []telegraf.Metric{
{ testutil.MustMetric(
Measurement: "syslog", "syslog",
Fields: map[string]interface{}{ map[string]string{
"severity": "notice",
"facility": "daemon",
"hostname": "web1",
"appname": "someservice",
},
map[string]interface{}{
"version": uint16(1), "version": uint16(1),
"timestamp": time.Unix(1456029177, 0).UnixNano(), "timestamp": time.Unix(1456029177, 0).UnixNano(),
"procid": "2341", "procid": "2341",
@ -37,19 +43,19 @@ func getTestCasesForOctetCounting() []testCaseStream {
"severity_code": 5, "severity_code": 5,
"facility_code": 3, "facility_code": 3,
}, },
Tags: map[string]string{ defaultTime,
),
},
wantBestEffort: []telegraf.Metric{
testutil.MustMetric(
"syslog",
map[string]string{
"severity": "notice", "severity": "notice",
"facility": "daemon", "facility": "daemon",
"hostname": "web1", "hostname": "web1",
"appname": "someservice", "appname": "someservice",
}, },
Time: defaultTime, map[string]interface{}{
},
},
wantBestEffort: []testutil.Metric{
{
Measurement: "syslog",
Fields: map[string]interface{}{
"version": uint16(1), "version": uint16(1),
"timestamp": time.Unix(1456029177, 0).UnixNano(), "timestamp": time.Unix(1456029177, 0).UnixNano(),
"procid": "2341", "procid": "2341",
@ -61,221 +67,215 @@ func getTestCasesForOctetCounting() []testCaseStream {
"severity_code": 5, "severity_code": 5,
"facility_code": 3, "facility_code": 3,
}, },
Tags: map[string]string{ defaultTime,
"severity": "notice", ),
"facility": "daemon",
"hostname": "web1",
"appname": "someservice",
},
Time: defaultTime,
},
}, },
}, },
{ {
name: "1st/min/ok//2nd/min/ok", name: "1st/min/ok//2nd/min/ok",
data: []byte("16 <1>2 - - - - - -17 <4>11 - - - - - -"), data: []byte("16 <1>2 - - - - - -17 <4>11 - - - - - -"),
wantStrict: []testutil.Metric{ wantStrict: []telegraf.Metric{
{ testutil.MustMetric(
Measurement: "syslog", "syslog",
Fields: map[string]interface{}{ map[string]string{
"severity": "alert",
"facility": "kern",
},
map[string]interface{}{
"version": uint16(2), "version": uint16(2),
"severity_code": 1, "severity_code": 1,
"facility_code": 0, "facility_code": 0,
}, },
Tags: map[string]string{ defaultTime,
"severity": "alert", ),
testutil.MustMetric(
"syslog",
map[string]string{
"severity": "warning",
"facility": "kern", "facility": "kern",
}, },
Time: defaultTime, map[string]interface{}{
},
{
Measurement: "syslog",
Fields: map[string]interface{}{
"version": uint16(11), "version": uint16(11),
"severity_code": 4, "severity_code": 4,
"facility_code": 0, "facility_code": 0,
}, },
Tags: map[string]string{ defaultTime.Add(time.Nanosecond),
"severity": "warning", ),
},
wantBestEffort: []telegraf.Metric{
testutil.MustMetric(
"syslog",
map[string]string{
"severity": "alert",
"facility": "kern", "facility": "kern",
}, },
Time: defaultTime.Add(time.Nanosecond), map[string]interface{}{
},
},
wantBestEffort: []testutil.Metric{
{
Measurement: "syslog",
Fields: map[string]interface{}{
"version": uint16(2), "version": uint16(2),
"severity_code": 1, "severity_code": 1,
"facility_code": 0, "facility_code": 0,
}, },
Tags: map[string]string{ defaultTime,
"severity": "alert", ),
testutil.MustMetric(
"syslog",
map[string]string{
"severity": "warning",
"facility": "kern", "facility": "kern",
}, },
Time: defaultTime, map[string]interface{}{
},
{
Measurement: "syslog",
Fields: map[string]interface{}{
"version": uint16(11), "version": uint16(11),
"severity_code": 4, "severity_code": 4,
"facility_code": 0, "facility_code": 0,
}, },
Tags: map[string]string{ defaultTime.Add(time.Nanosecond),
"severity": "warning", ),
"facility": "kern",
},
Time: defaultTime.Add(time.Nanosecond),
},
}, },
}, },
{ {
name: "1st/utf8/ok", name: "1st/utf8/ok",
data: []byte("23 <1>1 - - - - - - hellø"), data: []byte("23 <1>1 - - - - - - hellø"),
wantStrict: []testutil.Metric{ wantStrict: []telegraf.Metric{
{ testutil.MustMetric(
Measurement: "syslog", "syslog",
Fields: map[string]interface{}{ map[string]string{
"severity": "alert",
"facility": "kern",
},
map[string]interface{}{
"version": uint16(1), "version": uint16(1),
"message": "hellø", "message": "hellø",
"severity_code": 1, "severity_code": 1,
"facility_code": 0, "facility_code": 0,
}, },
Tags: map[string]string{ defaultTime,
),
},
wantBestEffort: []telegraf.Metric{
testutil.MustMetric(
"syslog",
map[string]string{
"severity": "alert", "severity": "alert",
"facility": "kern", "facility": "kern",
}, },
Time: defaultTime, map[string]interface{}{
},
},
wantBestEffort: []testutil.Metric{
{
Measurement: "syslog",
Fields: map[string]interface{}{
"version": uint16(1), "version": uint16(1),
"message": "hellø", "message": "hellø",
"severity_code": 1, "severity_code": 1,
"facility_code": 0, "facility_code": 0,
}, },
Tags: map[string]string{ defaultTime,
"severity": "alert", ),
"facility": "kern",
},
Time: defaultTime,
},
}, },
}, },
{ {
name: "1st/nl/ok", // newline name: "1st/nl/ok", // newline
data: []byte("28 <1>3 - - - - - - hello\nworld"), data: []byte("28 <1>3 - - - - - - hello\nworld"),
wantStrict: []testutil.Metric{ wantStrict: []telegraf.Metric{
{ testutil.MustMetric(
Measurement: "syslog", "syslog",
Fields: map[string]interface{}{ map[string]string{
"severity": "alert",
"facility": "kern",
},
map[string]interface{}{
"version": uint16(3), "version": uint16(3),
"message": "hello\nworld", "message": "hello\nworld",
"severity_code": 1, "severity_code": 1,
"facility_code": 0, "facility_code": 0,
}, },
Tags: map[string]string{ defaultTime,
),
},
wantBestEffort: []telegraf.Metric{
testutil.MustMetric(
"syslog",
map[string]string{
"severity": "alert", "severity": "alert",
"facility": "kern", "facility": "kern",
}, },
Time: defaultTime, map[string]interface{}{
},
},
wantBestEffort: []testutil.Metric{
{
Measurement: "syslog",
Fields: map[string]interface{}{
"version": uint16(3), "version": uint16(3),
"message": "hello\nworld", "message": "hello\nworld",
"severity_code": 1, "severity_code": 1,
"facility_code": 0, "facility_code": 0,
}, },
Tags: map[string]string{ defaultTime,
"severity": "alert", ),
"facility": "kern",
},
Time: defaultTime,
},
}, },
}, },
{ {
name: "1st/uf/ko", // underflow (msglen less than provided octets) name: "1st/uf/ko", // underflow (msglen less than provided octets)
data: []byte("16 <1>2"), data: []byte("16 <1>2"),
wantStrict: nil, wantStrict: nil,
wantBestEffort: []testutil.Metric{ wantBestEffort: []telegraf.Metric{
{ testutil.MustMetric(
Measurement: "syslog", "syslog",
Fields: map[string]interface{}{ map[string]string{
"severity": "alert",
"facility": "kern",
},
map[string]interface{}{
"version": uint16(2), "version": uint16(2),
"severity_code": 1, "severity_code": 1,
"facility_code": 0, "facility_code": 0,
}, },
Tags: map[string]string{ defaultTime,
"severity": "alert", ),
"facility": "kern",
},
Time: defaultTime,
},
}, },
werr: 1, werr: 1,
}, },
{ {
name: "1st/min/ok", name: "1st/min/ok",
data: []byte("16 <1>1 - - - - - -"), data: []byte("16 <1>1 - - - - - -"),
wantStrict: []testutil.Metric{ wantStrict: []telegraf.Metric{
{ testutil.MustMetric(
Measurement: "syslog", "syslog",
Fields: map[string]interface{}{ map[string]string{
"severity": "alert",
"facility": "kern",
},
map[string]interface{}{
"version": uint16(1), "version": uint16(1),
"severity_code": 1, "severity_code": 1,
"facility_code": 0, "facility_code": 0,
}, },
Tags: map[string]string{ defaultTime,
),
},
wantBestEffort: []telegraf.Metric{
testutil.MustMetric(
"syslog",
map[string]string{
"severity": "alert", "severity": "alert",
"facility": "kern", "facility": "kern",
}, },
Time: defaultTime, map[string]interface{}{
},
},
wantBestEffort: []testutil.Metric{
{
Measurement: "syslog",
Fields: map[string]interface{}{
"version": uint16(1), "version": uint16(1),
"severity_code": 1, "severity_code": 1,
"facility_code": 0, "facility_code": 0,
}, },
Tags: map[string]string{ defaultTime,
"severity": "alert", ),
"facility": "kern",
},
Time: defaultTime,
},
}, },
}, },
{ {
name: "1st/uf/mf", // The first "underflow" message breaks also the second one name: "1st/uf/mf", // The first "underflow" message breaks also the second one
data: []byte("16 <1>217 <11>1 - - - - - -"), data: []byte("16 <1>217 <11>1 - - - - - -"),
wantStrict: nil, wantStrict: nil,
wantBestEffort: []testutil.Metric{ wantBestEffort: []telegraf.Metric{
{ testutil.MustMetric(
Measurement: "syslog", "syslog",
Fields: map[string]interface{}{ map[string]string{
"severity": "alert",
"facility": "kern",
},
map[string]interface{}{
"version": uint16(217), "version": uint16(217),
"severity_code": 1, "severity_code": 1,
"facility_code": 0, "facility_code": 0,
}, },
Tags: map[string]string{ defaultTime,
"severity": "alert", ),
"facility": "kern",
},
Time: defaultTime,
},
}, },
werr: 1, werr: 1,
}, },
@ -287,10 +287,16 @@ func getTestCasesForOctetCounting() []testCaseStream {
{ {
name: "1st/max/ok", name: "1st/max/ok",
data: []byte(fmt.Sprintf("8192 <%d>%d %s %s %s %s %s - %s", maxP, maxV, maxTS, maxH, maxA, maxPID, maxMID, message7681)), data: []byte(fmt.Sprintf("8192 <%d>%d %s %s %s %s %s - %s", maxP, maxV, maxTS, maxH, maxA, maxPID, maxMID, message7681)),
wantStrict: []testutil.Metric{ wantStrict: []telegraf.Metric{
{ testutil.MustMetric(
Measurement: "syslog", "syslog",
Fields: map[string]interface{}{ map[string]string{
"severity": "debug",
"facility": "local7",
"hostname": maxH,
"appname": maxA,
},
map[string]interface{}{
"version": maxV, "version": maxV,
"timestamp": time.Unix(1514764799, 999999000).UnixNano(), "timestamp": time.Unix(1514764799, 999999000).UnixNano(),
"message": message7681, "message": message7681,
@ -299,19 +305,19 @@ func getTestCasesForOctetCounting() []testCaseStream {
"facility_code": 23, "facility_code": 23,
"severity_code": 7, "severity_code": 7,
}, },
Tags: map[string]string{ defaultTime,
),
},
wantBestEffort: []telegraf.Metric{
testutil.MustMetric(
"syslog",
map[string]string{
"severity": "debug", "severity": "debug",
"facility": "local7", "facility": "local7",
"hostname": maxH, "hostname": maxH,
"appname": maxA, "appname": maxA,
}, },
Time: defaultTime, map[string]interface{}{
},
},
wantBestEffort: []testutil.Metric{
{
Measurement: "syslog",
Fields: map[string]interface{}{
"version": maxV, "version": maxV,
"timestamp": time.Unix(1514764799, 999999000).UnixNano(), "timestamp": time.Unix(1514764799, 999999000).UnixNano(),
"message": message7681, "message": message7681,
@ -320,14 +326,8 @@ func getTestCasesForOctetCounting() []testCaseStream {
"facility_code": 23, "facility_code": 23,
"severity_code": 7, "severity_code": 7,
}, },
Tags: map[string]string{ defaultTime,
"severity": "debug", ),
"facility": "local7",
"hostname": maxH,
"appname": maxA,
},
Time: defaultTime,
},
}, },
}, },
} }
@ -386,13 +386,7 @@ func testStrictOctetCounting(t *testing.T, protocol string, address string, want
if len(acc.Errors) != tc.werr { if len(acc.Errors) != tc.werr {
t.Fatalf("Got unexpected errors. want error = %v, errors = %v\n", tc.werr, acc.Errors) t.Fatalf("Got unexpected errors. want error = %v, errors = %v\n", tc.werr, acc.Errors)
} }
var got []testutil.Metric testutil.RequireMetricsEqual(t, tc.wantStrict, acc.GetTelegrafMetrics())
for _, metric := range acc.Metrics {
got = append(got, *metric)
}
if !cmp.Equal(tc.wantStrict, got) {
t.Fatalf("Got (+) / Want (-)\n %s", cmp.Diff(tc.wantStrict, got))
}
}) })
} }
} }
@ -440,14 +434,7 @@ func testBestEffortOctetCounting(t *testing.T, protocol string, address string,
acc.Wait(len(tc.wantBestEffort)) acc.Wait(len(tc.wantBestEffort))
} }
// Verify testutil.RequireMetricsEqual(t, tc.wantBestEffort, acc.GetTelegrafMetrics())
var got []testutil.Metric
for _, metric := range acc.Metrics {
got = append(got, *metric)
}
if !cmp.Equal(tc.wantBestEffort, got) {
t.Fatalf("Got (+) / Want (-)\n %s", cmp.Diff(tc.wantBestEffort, got))
}
}) })
} }
} }

257
plugins/inputs/syslog/rfc5426_test.go
View File

@ -10,7 +10,7 @@ import (
"testing" "testing"
"time" "time"
"github.com/google/go-cmp/cmp" "github.com/influxdata/telegraf"
"github.com/influxdata/telegraf/testutil" "github.com/influxdata/telegraf/testutil"
"github.com/stretchr/testify/require" "github.com/stretchr/testify/require"
) )
@ -25,73 +25,79 @@ func getTestCasesForRFC5426() []testCasePacket {
{ {
name: "complete", name: "complete",
data: []byte("<1>1 - - - - - - A"), data: []byte("<1>1 - - - - - - A"),
wantBestEffort: &testutil.Metric{ wantBestEffort: testutil.MustMetric(
Measurement: "syslog", "syslog",
Fields: map[string]interface{}{ map[string]string{
"severity": "alert",
"facility": "kern",
},
map[string]interface{}{
"version": uint16(1), "version": uint16(1),
"message": "A", "message": "A",
"facility_code": 0, "facility_code": 0,
"severity_code": 1, "severity_code": 1,
}, },
Tags: map[string]string{ defaultTime,
),
wantStrict: testutil.MustMetric(
"syslog",
map[string]string{
"severity": "alert", "severity": "alert",
"facility": "kern", "facility": "kern",
}, },
Time: defaultTime, map[string]interface{}{
},
wantStrict: &testutil.Metric{
Measurement: "syslog",
Fields: map[string]interface{}{
"version": uint16(1), "version": uint16(1),
"message": "A", "message": "A",
"facility_code": 0, "facility_code": 0,
"severity_code": 1, "severity_code": 1,
}, },
Tags: map[string]string{ defaultTime,
"severity": "alert", ),
"facility": "kern",
},
Time: defaultTime,
},
}, },
{ {
name: "one/per/packet", name: "one/per/packet",
data: []byte("<1>3 - - - - - - A<1>4 - - - - - - B"), data: []byte("<1>3 - - - - - - A<1>4 - - - - - - B"),
wantBestEffort: &testutil.Metric{ wantBestEffort: testutil.MustMetric(
Measurement: "syslog", "syslog",
Fields: map[string]interface{}{ map[string]string{
"severity": "alert",
"facility": "kern",
},
map[string]interface{}{
"version": uint16(3), "version": uint16(3),
"message": "A<1>4 - - - - - - B", "message": "A<1>4 - - - - - - B",
"severity_code": 1, "severity_code": 1,
"facility_code": 0, "facility_code": 0,
}, },
Tags: map[string]string{ defaultTime,
),
wantStrict: testutil.MustMetric(
"syslog",
map[string]string{
"severity": "alert", "severity": "alert",
"facility": "kern", "facility": "kern",
}, },
Time: defaultTime, map[string]interface{}{
},
wantStrict: &testutil.Metric{
Measurement: "syslog",
Fields: map[string]interface{}{
"version": uint16(3), "version": uint16(3),
"message": "A<1>4 - - - - - - B", "message": "A<1>4 - - - - - - B",
"severity_code": 1, "severity_code": 1,
"facility_code": 0, "facility_code": 0,
}, },
Tags: map[string]string{ defaultTime,
"severity": "alert", ),
"facility": "kern",
},
Time: defaultTime,
},
}, },
{ {
name: "average", name: "average",
data: []byte(`<29>1 2016-02-21T04:32:57+00:00 web1 someservice 2341 2 [origin][meta sequence="14125553" service="someservice"] "GET /v1/ok HTTP/1.1" 200 145 "-" "hacheck 0.9.0" 24306 127.0.0.1:40124 575`), data: []byte(`<29>1 2016-02-21T04:32:57+00:00 web1 someservice 2341 2 [origin][meta sequence="14125553" service="someservice"] "GET /v1/ok HTTP/1.1" 200 145 "-" "hacheck 0.9.0" 24306 127.0.0.1:40124 575`),
wantBestEffort: &testutil.Metric{ wantBestEffort: testutil.MustMetric(
Measurement: "syslog", "syslog",
Fields: map[string]interface{}{ map[string]string{
"severity": "notice",
"facility": "daemon",
"hostname": "web1",
"appname": "someservice",
},
map[string]interface{}{
"version": uint16(1), "version": uint16(1),
"timestamp": time.Unix(1456029177, 0).UnixNano(), "timestamp": time.Unix(1456029177, 0).UnixNano(),
"procid": "2341", "procid": "2341",
@ -103,17 +109,17 @@ func getTestCasesForRFC5426() []testCasePacket {
"severity_code": 5, "severity_code": 5,
"facility_code": 3, "facility_code": 3,
}, },
Tags: map[string]string{ defaultTime,
),
wantStrict: testutil.MustMetric(
"syslog",
map[string]string{
"severity": "notice", "severity": "notice",
"facility": "daemon", "facility": "daemon",
"hostname": "web1", "hostname": "web1",
"appname": "someservice", "appname": "someservice",
}, },
Time: defaultTime, map[string]interface{}{
},
wantStrict: &testutil.Metric{
Measurement: "syslog",
Fields: map[string]interface{}{
"version": uint16(1), "version": uint16(1),
"timestamp": time.Unix(1456029177, 0).UnixNano(), "timestamp": time.Unix(1456029177, 0).UnixNano(),
"procid": "2341", "procid": "2341",
@ -125,21 +131,21 @@ func getTestCasesForRFC5426() []testCasePacket {
"severity_code": 5, "severity_code": 5,
"facility_code": 3, "facility_code": 3,
}, },
Tags: map[string]string{ defaultTime,
"severity": "notice", ),
"facility": "daemon",
"hostname": "web1",
"appname": "someservice",
},
Time: defaultTime,
},
}, },
{ {
name: "max", name: "max",
data: []byte(fmt.Sprintf("<%d>%d %s %s %s %s %s - %s", maxP, maxV, maxTS, maxH, maxA, maxPID, maxMID, message7681)), data: []byte(fmt.Sprintf("<%d>%d %s %s %s %s %s - %s", maxP, maxV, maxTS, maxH, maxA, maxPID, maxMID, message7681)),
wantBestEffort: &testutil.Metric{ wantBestEffort: testutil.MustMetric(
Measurement: "syslog", "syslog",
Fields: map[string]interface{}{ map[string]string{
"severity": "debug",
"facility": "local7",
"hostname": maxH,
"appname": maxA,
},
map[string]interface{}{
"version": maxV, "version": maxV,
"timestamp": time.Unix(1514764799, 999999000).UnixNano(), "timestamp": time.Unix(1514764799, 999999000).UnixNano(),
"message": message7681, "message": message7681,
@ -148,17 +154,17 @@ func getTestCasesForRFC5426() []testCasePacket {
"severity_code": 7, "severity_code": 7,
"facility_code": 23, "facility_code": 23,
}, },
Tags: map[string]string{ defaultTime,
),
wantStrict: testutil.MustMetric(
"syslog",
map[string]string{
"severity": "debug", "severity": "debug",
"facility": "local7", "facility": "local7",
"hostname": maxH, "hostname": maxH,
"appname": maxA, "appname": maxA,
}, },
Time: defaultTime, map[string]interface{}{
},
wantStrict: &testutil.Metric{
Measurement: "syslog",
Fields: map[string]interface{}{
"version": maxV, "version": maxV,
"timestamp": time.Unix(1514764799, 999999000).UnixNano(), "timestamp": time.Unix(1514764799, 999999000).UnixNano(),
"message": message7681, "message": message7681,
@ -167,64 +173,58 @@ func getTestCasesForRFC5426() []testCasePacket {
"severity_code": 7, "severity_code": 7,
"facility_code": 23, "facility_code": 23,
}, },
Tags: map[string]string{ defaultTime,
"severity": "debug", ),
"facility": "local7",
"hostname": maxH,
"appname": maxA,
},
Time: defaultTime,
},
}, },
{ {
name: "minimal/incomplete", name: "minimal/incomplete",
data: []byte("<1>2"), data: []byte("<1>2"),
wantBestEffort: &testutil.Metric{ wantBestEffort: testutil.MustMetric(
Measurement: "syslog", "syslog",
Fields: map[string]interface{}{ map[string]string{
"severity": "alert",
"facility": "kern",
},
map[string]interface{}{
"version": uint16(2), "version": uint16(2),
"facility_code": 0, "facility_code": 0,
"severity_code": 1, "severity_code": 1,
}, },
Tags: map[string]string{ defaultTime,
"severity": "alert", ),
"facility": "kern",
},
Time: defaultTime,
},
werr: true, werr: true,
}, },
{ {
name: "trim message", name: "trim message",
data: []byte("<1>1 - - - - - - \tA\n"), data: []byte("<1>1 - - - - - - \tA\n"),
wantBestEffort: &testutil.Metric{ wantBestEffort: testutil.MustMetric(
Measurement: "syslog", "syslog",
Fields: map[string]interface{}{ map[string]string{
"severity": "alert",
"facility": "kern",
},
map[string]interface{}{
"version": uint16(1), "version": uint16(1),
"message": "\tA", "message": "\tA",
"facility_code": 0, "facility_code": 0,
"severity_code": 1, "severity_code": 1,
}, },
Tags: map[string]string{ defaultTime,
),
wantStrict: testutil.MustMetric(
"syslog",
map[string]string{
"severity": "alert", "severity": "alert",
"facility": "kern", "facility": "kern",
}, },
Time: defaultTime, map[string]interface{}{
},
wantStrict: &testutil.Metric{
Measurement: "syslog",
Fields: map[string]interface{}{
"version": uint16(1), "version": uint16(1),
"message": "\tA", "message": "\tA",
"facility_code": 0, "facility_code": 0,
"severity_code": 1, "severity_code": 1,
}, },
Tags: map[string]string{ defaultTime,
"severity": "alert", ),
"facility": "kern",
},
Time: defaultTime,
},
}, },
} }
@ -269,19 +269,17 @@ func testRFC5426(t *testing.T, protocol string, address string, bestEffort bool)
} }
// Compare // Compare
var got *testutil.Metric var got telegraf.Metric
var want *testutil.Metric var want telegraf.Metric
if len(acc.Metrics) > 0 { if len(acc.Metrics) > 0 {
got = acc.Metrics[0] got = acc.GetTelegrafMetrics()[0]
} }
if bestEffort { if bestEffort {
want = tc.wantBestEffort want = tc.wantBestEffort
} else { } else {
want = tc.wantStrict want = tc.wantStrict
} }
if !cmp.Equal(want, got) { testutil.RequireMetricEqual(t, want, got)
t.Fatalf("Got (+) / Want (-)\n %s", cmp.Diff(want, got))
}
}) })
} }
} }
@ -346,23 +344,22 @@ func TestTimeIncrement_udp(t *testing.T) {
// Wait // Wait
acc.Wait(1) acc.Wait(1)
want := &testutil.Metric{ want := []telegraf.Metric{
Measurement: "syslog", testutil.MustMetric(
Fields: map[string]interface{}{ "syslog",
map[string]string{
"severity": "alert",
"facility": "kern",
},
map[string]interface{}{
"version": uint16(1), "version": uint16(1),
"facility_code": 0, "facility_code": 0,
"severity_code": 1, "severity_code": 1,
}, },
Tags: map[string]string{ getNow(),
"severity": "alert", ),
"facility": "kern",
},
Time: getNow(),
}
if !cmp.Equal(want, acc.Metrics[0]) {
t.Fatalf("Got (+) / Want (-)\n %s", cmp.Diff(want, acc.Metrics[0]))
} }
testutil.RequireMetricsEqual(t, want, acc.GetTelegrafMetrics())
// New one with different time // New one with different time
atomic.StoreInt64(&i, atomic.LoadInt64(&i)+1) atomic.StoreInt64(&i, atomic.LoadInt64(&i)+1)
@ -377,23 +374,22 @@ func TestTimeIncrement_udp(t *testing.T) {
// Wait // Wait
acc.Wait(1) acc.Wait(1)
want = &testutil.Metric{ want = []telegraf.Metric{
Measurement: "syslog", testutil.MustMetric(
Fields: map[string]interface{}{ "syslog",
map[string]string{
"severity": "alert",
"facility": "kern",
},
map[string]interface{}{
"version": uint16(1), "version": uint16(1),
"facility_code": 0, "facility_code": 0,
"severity_code": 1, "severity_code": 1,
}, },
Tags: map[string]string{ getNow(),
"severity": "alert", ),
"facility": "kern",
},
Time: getNow(),
}
if !cmp.Equal(want, acc.Metrics[0]) {
t.Fatalf("Got (+) / Want (-)\n %s", cmp.Diff(want, acc.Metrics[0]))
} }
testutil.RequireMetricsEqual(t, want, acc.GetTelegrafMetrics())
// New one with same time as previous one // New one with same time as previous one
@ -407,21 +403,20 @@ func TestTimeIncrement_udp(t *testing.T) {
// Wait // Wait
acc.Wait(1) acc.Wait(1)
want = &testutil.Metric{ want = []telegraf.Metric{
Measurement: "syslog", testutil.MustMetric(
Fields: map[string]interface{}{ "syslog",
map[string]string{
"severity": "alert",
"facility": "kern",
},
map[string]interface{}{
"version": uint16(1), "version": uint16(1),
"facility_code": 0, "facility_code": 0,
"severity_code": 1, "severity_code": 1,
}, },
Tags: map[string]string{ getNow().Add(time.Nanosecond),
"severity": "alert", ),
"facility": "kern",
},
Time: getNow().Add(time.Nanosecond),
}
if !cmp.Equal(want, acc.Metrics[0]) {
t.Fatalf("Got (+) / Want (-)\n %s", cmp.Diff(want, acc.Metrics[0]))
} }
testutil.RequireMetricsEqual(t, want, acc.GetTelegrafMetrics())
} }

11
plugins/inputs/zipkin/convert_test.go
View File

@ -121,6 +121,7 @@ func TestLineProtocolConverter_Record(t *testing.T) {
"duration_ns": (time.Duration(53106) * time.Microsecond).Nanoseconds(), "duration_ns": (time.Duration(53106) * time.Microsecond).Nanoseconds(),
}, },
Time: time.Unix(0, 1498688360851331000).UTC(), Time: time.Unix(0, 1498688360851331000).UTC(),
Type: telegraf.Untyped,
}, },
{ {
Measurement: "zipkin", Measurement: "zipkin",
@ -138,6 +139,7 @@ func TestLineProtocolConverter_Record(t *testing.T) {
"duration_ns": (time.Duration(53106) * time.Microsecond).Nanoseconds(), "duration_ns": (time.Duration(53106) * time.Microsecond).Nanoseconds(),
}, },
Time: time.Unix(0, 1498688360851331000).UTC(), Time: time.Unix(0, 1498688360851331000).UTC(),
Type: telegraf.Untyped,
}, },
{ {
Measurement: "zipkin", Measurement: "zipkin",
@ -152,6 +154,7 @@ func TestLineProtocolConverter_Record(t *testing.T) {
"duration_ns": (time.Duration(50410) * time.Microsecond).Nanoseconds(), "duration_ns": (time.Duration(50410) * time.Microsecond).Nanoseconds(),
}, },
Time: time.Unix(0, 1498688360904552000).UTC(), Time: time.Unix(0, 1498688360904552000).UTC(),
Type: telegraf.Untyped,
}, },
{ {
Measurement: "zipkin", Measurement: "zipkin",
@ -169,6 +172,7 @@ func TestLineProtocolConverter_Record(t *testing.T) {
"duration_ns": (time.Duration(50410) * time.Microsecond).Nanoseconds(), "duration_ns": (time.Duration(50410) * time.Microsecond).Nanoseconds(),
}, },
Time: time.Unix(0, 1498688360904552000).UTC(), Time: time.Unix(0, 1498688360904552000).UTC(),
Type: telegraf.Untyped,
}, },
{ {
Measurement: "zipkin", Measurement: "zipkin",
@ -183,6 +187,7 @@ func TestLineProtocolConverter_Record(t *testing.T) {
"duration_ns": (time.Duration(103680) * time.Microsecond).Nanoseconds(), "duration_ns": (time.Duration(103680) * time.Microsecond).Nanoseconds(),
}, },
Time: time.Unix(0, 1498688360851318000).UTC(), Time: time.Unix(0, 1498688360851318000).UTC(),
Type: telegraf.Untyped,
}, },
{ {
Measurement: "zipkin", Measurement: "zipkin",
@ -199,6 +204,7 @@ func TestLineProtocolConverter_Record(t *testing.T) {
"duration_ns": (time.Duration(103680) * time.Microsecond).Nanoseconds(), "duration_ns": (time.Duration(103680) * time.Microsecond).Nanoseconds(),
}, },
Time: time.Unix(0, 1498688360851318000).UTC(), Time: time.Unix(0, 1498688360851318000).UTC(),
Type: telegraf.Untyped,
}, },
{ {
Measurement: "zipkin", Measurement: "zipkin",
@ -215,6 +221,7 @@ func TestLineProtocolConverter_Record(t *testing.T) {
"duration_ns": (time.Duration(103680) * time.Microsecond).Nanoseconds(), "duration_ns": (time.Duration(103680) * time.Microsecond).Nanoseconds(),
}, },
Time: time.Unix(0, 1498688360851318000).UTC(), Time: time.Unix(0, 1498688360851318000).UTC(),
Type: telegraf.Untyped,
}, },
{ {
Measurement: "zipkin", Measurement: "zipkin",
@ -231,6 +238,7 @@ func TestLineProtocolConverter_Record(t *testing.T) {
"duration_ns": (time.Duration(103680) * time.Microsecond).Nanoseconds(), "duration_ns": (time.Duration(103680) * time.Microsecond).Nanoseconds(),
}, },
Time: time.Unix(0, 1498688360851318000).UTC(), Time: time.Unix(0, 1498688360851318000).UTC(),
Type: telegraf.Untyped,
}, },
{ {
Measurement: "zipkin", Measurement: "zipkin",
@ -248,6 +256,7 @@ func TestLineProtocolConverter_Record(t *testing.T) {
"duration_ns": (time.Duration(103680) * time.Microsecond).Nanoseconds(), "duration_ns": (time.Duration(103680) * time.Microsecond).Nanoseconds(),
}, },
Time: time.Unix(0, 1498688360851318000).UTC(), Time: time.Unix(0, 1498688360851318000).UTC(),
Type: telegraf.Untyped,
}, },
}, },
wantErr: false, wantErr: false,
@ -296,6 +305,7 @@ func TestLineProtocolConverter_Record(t *testing.T) {
"duration_ns": (time.Duration(1) * time.Nanosecond).Nanoseconds(), "duration_ns": (time.Duration(1) * time.Nanosecond).Nanoseconds(),
}, },
Time: time.Unix(1, 0).UTC(), Time: time.Unix(1, 0).UTC(),
Type: telegraf.Untyped,
}, },
{ {
Measurement: "zipkin", Measurement: "zipkin",
@ -312,6 +322,7 @@ func TestLineProtocolConverter_Record(t *testing.T) {
"duration_ns": (time.Duration(1) * time.Nanosecond).Nanoseconds(), "duration_ns": (time.Duration(1) * time.Nanosecond).Nanoseconds(),
}, },
Time: time.Unix(1, 0).UTC(), Time: time.Unix(1, 0).UTC(),
Type: telegraf.Untyped,
}, },
}, },
}, },

36
plugins/inputs/zipkin/zipkin_test.go
View File

@ -9,6 +9,7 @@ import (
"time" "time"
"github.com/google/go-cmp/cmp" "github.com/google/go-cmp/cmp"
"github.com/influxdata/telegraf"
"github.com/influxdata/telegraf/testutil" "github.com/influxdata/telegraf/testutil"
) )
@ -40,6 +41,7 @@ func TestZipkinPlugin(t *testing.T) {
"duration_ns": (time.Duration(53106) * time.Microsecond).Nanoseconds(), "duration_ns": (time.Duration(53106) * time.Microsecond).Nanoseconds(),
}, },
Time: time.Unix(0, 1498688360851331000).UTC(), Time: time.Unix(0, 1498688360851331000).UTC(),
Type: telegraf.Untyped,
}, },
{ {
Measurement: "zipkin", Measurement: "zipkin",
@ -57,6 +59,7 @@ func TestZipkinPlugin(t *testing.T) {
"duration_ns": (time.Duration(53106) * time.Microsecond).Nanoseconds(), "duration_ns": (time.Duration(53106) * time.Microsecond).Nanoseconds(),
}, },
Time: time.Unix(0, 1498688360851331000).UTC(), Time: time.Unix(0, 1498688360851331000).UTC(),
Type: telegraf.Untyped,
}, },
{ {
Measurement: "zipkin", Measurement: "zipkin",
@ -71,6 +74,7 @@ func TestZipkinPlugin(t *testing.T) {
"duration_ns": (time.Duration(50410) * time.Microsecond).Nanoseconds(), "duration_ns": (time.Duration(50410) * time.Microsecond).Nanoseconds(),
}, },
Time: time.Unix(0, 1498688360904552000).UTC(), Time: time.Unix(0, 1498688360904552000).UTC(),
Type: telegraf.Untyped,
}, },
{ {
Measurement: "zipkin", Measurement: "zipkin",
@ -88,6 +92,7 @@ func TestZipkinPlugin(t *testing.T) {
"duration_ns": (time.Duration(50410) * time.Microsecond).Nanoseconds(), "duration_ns": (time.Duration(50410) * time.Microsecond).Nanoseconds(),
}, },
Time: time.Unix(0, 1498688360904552000).UTC(), Time: time.Unix(0, 1498688360904552000).UTC(),
Type: telegraf.Untyped,
}, },
{ {
Measurement: "zipkin", Measurement: "zipkin",
@ -102,6 +107,7 @@ func TestZipkinPlugin(t *testing.T) {
"duration_ns": (time.Duration(103680) * time.Microsecond).Nanoseconds(), "duration_ns": (time.Duration(103680) * time.Microsecond).Nanoseconds(),
}, },
Time: time.Unix(0, 1498688360851318000).UTC(), Time: time.Unix(0, 1498688360851318000).UTC(),
Type: telegraf.Untyped,
}, },
{ {
Measurement: "zipkin", Measurement: "zipkin",
@ -118,6 +124,7 @@ func TestZipkinPlugin(t *testing.T) {
"duration_ns": (time.Duration(103680) * time.Microsecond).Nanoseconds(), "duration_ns": (time.Duration(103680) * time.Microsecond).Nanoseconds(),
}, },
Time: time.Unix(0, 1498688360851318000).UTC(), Time: time.Unix(0, 1498688360851318000).UTC(),
Type: telegraf.Untyped,
}, },
{ {
Measurement: "zipkin", Measurement: "zipkin",
@ -134,6 +141,7 @@ func TestZipkinPlugin(t *testing.T) {
"duration_ns": (time.Duration(103680) * time.Microsecond).Nanoseconds(), "duration_ns": (time.Duration(103680) * time.Microsecond).Nanoseconds(),
}, },
Time: time.Unix(0, 1498688360851318000).UTC(), Time: time.Unix(0, 1498688360851318000).UTC(),
Type: telegraf.Untyped,
}, },
{ {
Measurement: "zipkin", Measurement: "zipkin",
@ -150,6 +158,7 @@ func TestZipkinPlugin(t *testing.T) {
"duration_ns": (time.Duration(103680) * time.Microsecond).Nanoseconds(), "duration_ns": (time.Duration(103680) * time.Microsecond).Nanoseconds(),
}, },
Time: time.Unix(0, 1498688360851318000).UTC(), Time: time.Unix(0, 1498688360851318000).UTC(),
Type: telegraf.Untyped,
}, },
{ {
Measurement: "zipkin", Measurement: "zipkin",
@ -167,6 +176,7 @@ func TestZipkinPlugin(t *testing.T) {
"duration_ns": (time.Duration(103680) * time.Microsecond).Nanoseconds(), "duration_ns": (time.Duration(103680) * time.Microsecond).Nanoseconds(),
}, },
Time: time.Unix(0, 1498688360851318000).UTC(), Time: time.Unix(0, 1498688360851318000).UTC(),
Type: telegraf.Untyped,
}, },
}, },
wantErr: false, wantErr: false,
@ -189,6 +199,7 @@ func TestZipkinPlugin(t *testing.T) {
"duration_ns": (time.Duration(1) * time.Microsecond).Nanoseconds(), "duration_ns": (time.Duration(1) * time.Microsecond).Nanoseconds(),
}, },
Time: time.Unix(0, 1433330263415871*int64(time.Microsecond)).UTC(), Time: time.Unix(0, 1433330263415871*int64(time.Microsecond)).UTC(),
Type: telegraf.Untyped,
}, },
{ {
Measurement: "zipkin", Measurement: "zipkin",
@ -205,6 +216,7 @@ func TestZipkinPlugin(t *testing.T) {
"duration_ns": (time.Duration(1) * time.Microsecond).Nanoseconds(), "duration_ns": (time.Duration(1) * time.Microsecond).Nanoseconds(),
}, },
Time: time.Unix(0, 1433330263415871*int64(time.Microsecond)).UTC(), Time: time.Unix(0, 1433330263415871*int64(time.Microsecond)).UTC(),
Type: telegraf.Untyped,
}, },
{ {
Measurement: "zipkin", Measurement: "zipkin",
@ -221,6 +233,7 @@ func TestZipkinPlugin(t *testing.T) {
"duration_ns": (time.Duration(1) * time.Microsecond).Nanoseconds(), "duration_ns": (time.Duration(1) * time.Microsecond).Nanoseconds(),
}, },
Time: time.Unix(0, 1433330263415871*int64(time.Microsecond)).UTC(), Time: time.Unix(0, 1433330263415871*int64(time.Microsecond)).UTC(),
Type: telegraf.Untyped,
}, },
}, },
}, },
@ -240,7 +253,9 @@ func TestZipkinPlugin(t *testing.T) {
}, },
Fields: map[string]interface{}{ Fields: map[string]interface{}{
"duration_ns": int64(3000000), "duration_ns": int64(3000000),
}, Time: time.Unix(0, 1503031538791000*int64(time.Microsecond)).UTC(), },
Time: time.Unix(0, 1503031538791000*int64(time.Microsecond)).UTC(),
Type: telegraf.Untyped,
}, },
{ {
Measurement: "zipkin", Measurement: "zipkin",
@ -257,6 +272,7 @@ func TestZipkinPlugin(t *testing.T) {
"duration_ns": int64(3000000), "duration_ns": int64(3000000),
}, },
Time: time.Unix(0, 1503031538791000*int64(time.Microsecond)).UTC(), Time: time.Unix(0, 1503031538791000*int64(time.Microsecond)).UTC(),
Type: telegraf.Untyped,
}, },
{ {
Measurement: "zipkin", Measurement: "zipkin",
@ -273,6 +289,7 @@ func TestZipkinPlugin(t *testing.T) {
"duration_ns": int64(3000000), "duration_ns": int64(3000000),
}, },
Time: time.Unix(0, 1503031538791000*int64(time.Microsecond)).UTC(), Time: time.Unix(0, 1503031538791000*int64(time.Microsecond)).UTC(),
Type: telegraf.Untyped,
}, },
{ {
Measurement: "zipkin", Measurement: "zipkin",
@ -290,6 +307,7 @@ func TestZipkinPlugin(t *testing.T) {
"duration_ns": int64(3000000), "duration_ns": int64(3000000),
}, },
Time: time.Unix(0, 1503031538791000*int64(time.Microsecond)).UTC(), Time: time.Unix(0, 1503031538791000*int64(time.Microsecond)).UTC(),
Type: telegraf.Untyped,
}, },
{ {
Measurement: "zipkin", Measurement: "zipkin",
@ -307,6 +325,7 @@ func TestZipkinPlugin(t *testing.T) {
"duration_ns": int64(3000000), "duration_ns": int64(3000000),
}, },
Time: time.Unix(0, 1503031538791000*int64(time.Microsecond)).UTC(), Time: time.Unix(0, 1503031538791000*int64(time.Microsecond)).UTC(),
Type: telegraf.Untyped,
}, },
{ {
Measurement: "zipkin", Measurement: "zipkin",
@ -324,6 +343,7 @@ func TestZipkinPlugin(t *testing.T) {
"duration_ns": int64(3000000), "duration_ns": int64(3000000),
}, },
Time: time.Unix(0, 1503031538791000*int64(time.Microsecond)).UTC(), Time: time.Unix(0, 1503031538791000*int64(time.Microsecond)).UTC(),
Type: telegraf.Untyped,
}, },
{ {
Measurement: "zipkin", Measurement: "zipkin",
@ -338,6 +358,7 @@ func TestZipkinPlugin(t *testing.T) {
"duration_ns": int64(10000000), "duration_ns": int64(10000000),
}, },
Time: time.Unix(0, 1503031538786000*int64(time.Microsecond)).UTC(), Time: time.Unix(0, 1503031538786000*int64(time.Microsecond)).UTC(),
Type: telegraf.Untyped,
}, },
{ {
Measurement: "zipkin", Measurement: "zipkin",
@ -354,6 +375,7 @@ func TestZipkinPlugin(t *testing.T) {
"duration_ns": int64(10000000), "duration_ns": int64(10000000),
}, },
Time: time.Unix(0, 1503031538786000*int64(time.Microsecond)).UTC(), Time: time.Unix(0, 1503031538786000*int64(time.Microsecond)).UTC(),
Type: telegraf.Untyped,
}, },
{ {
Measurement: "zipkin", Measurement: "zipkin",
@ -370,6 +392,7 @@ func TestZipkinPlugin(t *testing.T) {
"duration_ns": int64(10000000), "duration_ns": int64(10000000),
}, },
Time: time.Unix(0, 1503031538786000*int64(time.Microsecond)).UTC(), Time: time.Unix(0, 1503031538786000*int64(time.Microsecond)).UTC(),
Type: telegraf.Untyped,
}, },
{ {
Measurement: "zipkin", Measurement: "zipkin",
@ -387,6 +410,7 @@ func TestZipkinPlugin(t *testing.T) {
"duration_ns": int64(10000000), "duration_ns": int64(10000000),
}, },
Time: time.Unix(0, 1503031538786000*int64(time.Microsecond)).UTC(), Time: time.Unix(0, 1503031538786000*int64(time.Microsecond)).UTC(),
Type: telegraf.Untyped,
}, },
{ {
Measurement: "zipkin", Measurement: "zipkin",
@ -404,6 +428,7 @@ func TestZipkinPlugin(t *testing.T) {
"duration_ns": int64(10000000), "duration_ns": int64(10000000),
}, },
Time: time.Unix(0, 1503031538786000*int64(time.Microsecond)).UTC(), Time: time.Unix(0, 1503031538786000*int64(time.Microsecond)).UTC(),
Type: telegraf.Untyped,
}, },
{ {
Measurement: "zipkin", Measurement: "zipkin",
@ -421,6 +446,7 @@ func TestZipkinPlugin(t *testing.T) {
"duration_ns": int64(10000000), "duration_ns": int64(10000000),
}, },
Time: time.Unix(0, 1503031538786000*int64(time.Microsecond)).UTC(), Time: time.Unix(0, 1503031538786000*int64(time.Microsecond)).UTC(),
Type: telegraf.Untyped,
}, },
{ {
Measurement: "zipkin", Measurement: "zipkin",
@ -438,6 +464,7 @@ func TestZipkinPlugin(t *testing.T) {
"duration_ns": int64(10000000), "duration_ns": int64(10000000),
}, },
Time: time.Unix(0, 1503031538786000*int64(time.Microsecond)).UTC(), Time: time.Unix(0, 1503031538786000*int64(time.Microsecond)).UTC(),
Type: telegraf.Untyped,
}, },
{ {
Measurement: "zipkin", Measurement: "zipkin",
@ -455,6 +482,7 @@ func TestZipkinPlugin(t *testing.T) {
"duration_ns": int64(10000000), "duration_ns": int64(10000000),
}, },
Time: time.Unix(0, 1503031538786000*int64(time.Microsecond)).UTC(), Time: time.Unix(0, 1503031538786000*int64(time.Microsecond)).UTC(),
Type: telegraf.Untyped,
}, },
{ {
Measurement: "zipkin", Measurement: "zipkin",
@ -469,6 +497,7 @@ func TestZipkinPlugin(t *testing.T) {
"duration_ns": int64(23393000), "duration_ns": int64(23393000),
}, },
Time: time.Unix(0, 1503031538778000*int64(time.Microsecond)).UTC(), Time: time.Unix(0, 1503031538778000*int64(time.Microsecond)).UTC(),
Type: telegraf.Untyped,
}, },
{ {
Measurement: "zipkin", Measurement: "zipkin",
@ -485,6 +514,7 @@ func TestZipkinPlugin(t *testing.T) {
"duration_ns": int64(23393000), "duration_ns": int64(23393000),
}, },
Time: time.Unix(0, 1503031538778000*int64(time.Microsecond)).UTC(), Time: time.Unix(0, 1503031538778000*int64(time.Microsecond)).UTC(),
Type: telegraf.Untyped,
}, },
{ {
Measurement: "zipkin", Measurement: "zipkin",
@ -501,6 +531,7 @@ func TestZipkinPlugin(t *testing.T) {
"duration_ns": int64(23393000), "duration_ns": int64(23393000),
}, },
Time: time.Unix(0, 1503031538778000*int64(time.Microsecond)).UTC(), Time: time.Unix(0, 1503031538778000*int64(time.Microsecond)).UTC(),
Type: telegraf.Untyped,
}, },
{ {
Measurement: "zipkin", Measurement: "zipkin",
@ -518,6 +549,7 @@ func TestZipkinPlugin(t *testing.T) {
"duration_ns": int64(23393000), "duration_ns": int64(23393000),
}, },
Time: time.Unix(0, 1503031538778000*int64(time.Microsecond)).UTC(), Time: time.Unix(0, 1503031538778000*int64(time.Microsecond)).UTC(),
Type: telegraf.Untyped,
}, },
{ {
Measurement: "zipkin", Measurement: "zipkin",
@ -535,6 +567,7 @@ func TestZipkinPlugin(t *testing.T) {
"duration_ns": int64(23393000), "duration_ns": int64(23393000),
}, },
Time: time.Unix(0, 1503031538778000*int64(time.Microsecond)).UTC(), Time: time.Unix(0, 1503031538778000*int64(time.Microsecond)).UTC(),
Type: telegraf.Untyped,
}, },
{ {
Measurement: "zipkin", Measurement: "zipkin",
@ -552,6 +585,7 @@ func TestZipkinPlugin(t *testing.T) {
"duration_ns": int64(23393000), "duration_ns": int64(23393000),
}, },
Time: time.Unix(0, 1503031538778000*int64(time.Microsecond)).UTC(), Time: time.Unix(0, 1503031538778000*int64(time.Microsecond)).UTC(),
Type: telegraf.Untyped,
}, },
}, },
}, },

156
plugins/outputs/prometheus_client/prometheus_client_test.go → plugins/outputs/prometheus_client/prometheus_client_v1_test.go
View File

@ -1,18 +1,22 @@
package prometheus package prometheus
import ( import (
"fmt"
"io/ioutil" "io/ioutil"
"net/http" "net/http"
"net/http/httptest"
"strings" "strings"
"testing" "testing"
"time" "time"
"github.com/influxdata/telegraf" "github.com/influxdata/telegraf"
inputs "github.com/influxdata/telegraf/plugins/inputs/prometheus"
"github.com/influxdata/telegraf/testutil" "github.com/influxdata/telegraf/testutil"
"github.com/stretchr/testify/require" "github.com/stretchr/testify/require"
) )
func TestMetricVersion1(t *testing.T) { func TestMetricVersion1(t *testing.T) {
Logger := testutil.Logger{Name: "outputs.prometheus_client"}
tests := []struct { tests := []struct {
name string name string
output *PrometheusClient output *PrometheusClient
@ -26,7 +30,7 @@ func TestMetricVersion1(t *testing.T) {
MetricVersion: 1, MetricVersion: 1,
CollectorsExclude: []string{"gocollector", "process"}, CollectorsExclude: []string{"gocollector", "process"},
Path: "/metrics", Path: "/metrics",
Log: testutil.Logger{}, Log: Logger,
}, },
metrics: []telegraf.Metric{ metrics: []telegraf.Metric{
testutil.MustMetric( testutil.MustMetric(
@ -53,7 +57,7 @@ cpu_time_idle{host="example.org"} 42
MetricVersion: 1, MetricVersion: 1,
CollectorsExclude: []string{"gocollector", "process"}, CollectorsExclude: []string{"gocollector", "process"},
Path: "/metrics", Path: "/metrics",
Log: testutil.Logger{}, Log: Logger,
}, },
metrics: []telegraf.Metric{ metrics: []telegraf.Metric{
testutil.MustMetric( testutil.MustMetric(
@ -80,7 +84,7 @@ cpu_time_idle{host="example.org"} 42
MetricVersion: 1, MetricVersion: 1,
CollectorsExclude: []string{"gocollector", "process"}, CollectorsExclude: []string{"gocollector", "process"},
Path: "/metrics", Path: "/metrics",
Log: testutil.Logger{}, Log: Logger,
}, },
metrics: []telegraf.Metric{ metrics: []telegraf.Metric{
testutil.MustMetric( testutil.MustMetric(
@ -108,7 +112,7 @@ cpu_time_idle{host="example.org"} 42
MetricVersion: 1, MetricVersion: 1,
CollectorsExclude: []string{"gocollector", "process"}, CollectorsExclude: []string{"gocollector", "process"},
Path: "/metrics", Path: "/metrics",
Log: testutil.Logger{}, Log: Logger,
}, },
metrics: []telegraf.Metric{ metrics: []telegraf.Metric{
testutil.MustMetric( testutil.MustMetric(
@ -136,7 +140,7 @@ cpu_time_idle{host="example.org"} 42
MetricVersion: 1, MetricVersion: 1,
CollectorsExclude: []string{"gocollector", "process"}, CollectorsExclude: []string{"gocollector", "process"},
Path: "/metrics", Path: "/metrics",
Log: testutil.Logger{}, Log: Logger,
}, },
metrics: []telegraf.Metric{ metrics: []telegraf.Metric{
testutil.MustMetric( testutil.MustMetric(
@ -176,7 +180,7 @@ http_request_duration_seconds_count 144320
MetricVersion: 1, MetricVersion: 1,
CollectorsExclude: []string{"gocollector", "process"}, CollectorsExclude: []string{"gocollector", "process"},
Path: "/metrics", Path: "/metrics",
Log: testutil.Logger{}, Log: Logger,
}, },
metrics: []telegraf.Metric{ metrics: []telegraf.Metric{
testutil.MustMetric( testutil.MustMetric(
@ -238,67 +242,133 @@ rpc_duration_seconds_count 2693
} }
} }
func TestMetricVersion2(t *testing.T) { func TestRoundTripMetricVersion1(t *testing.T) {
Logger := testutil.Logger{Name: "outputs.prometheus_client"}
tests := []struct { tests := []struct {
name string name string
output *PrometheusClient data []byte
metrics []telegraf.Metric
expected []byte
}{ }{
{ {
name: "simple", name: "untyped",
output: &PrometheusClient{ data: []byte(`
Listen: ":0",
MetricVersion: 2,
CollectorsExclude: []string{"gocollector", "process"},
Path: "/metrics",
Log: testutil.Logger{},
},
metrics: []telegraf.Metric{
testutil.MustMetric(
"cpu",
map[string]string{
"host": "example.org",
},
map[string]interface{}{
"time_idle": 42.0,
},
time.Unix(0, 0),
),
},
expected: []byte(`
# HELP cpu_time_idle Telegraf collected metric # HELP cpu_time_idle Telegraf collected metric
# TYPE cpu_time_idle untyped # TYPE cpu_time_idle untyped
cpu_time_idle{host="example.org"} 42 cpu_time_idle{host="example.org"} 42
`),
},
{
name: "counter",
data: []byte(`
# HELP cpu_time_idle Telegraf collected metric
# TYPE cpu_time_idle counter
cpu_time_idle{host="example.org"} 42
`),
},
{
name: "gauge",
data: []byte(`
# HELP cpu_time_idle Telegraf collected metric
# TYPE cpu_time_idle gauge
cpu_time_idle{host="example.org"} 42
`),
},
{
name: "multi",
data: []byte(`
# HELP cpu_time_guest Telegraf collected metric
# TYPE cpu_time_guest gauge
cpu_time_guest{host="one.example.org"} 42
cpu_time_guest{host="two.example.org"} 42
# HELP cpu_time_idle Telegraf collected metric
# TYPE cpu_time_idle gauge
cpu_time_idle{host="one.example.org"} 42
cpu_time_idle{host="two.example.org"} 42
`),
},
{
name: "histogram",
data: []byte(`
# HELP http_request_duration_seconds Telegraf collected metric
# TYPE http_request_duration_seconds histogram
http_request_duration_seconds_bucket{le="0.05"} 24054
http_request_duration_seconds_bucket{le="0.1"} 33444
http_request_duration_seconds_bucket{le="0.2"} 100392
http_request_duration_seconds_bucket{le="0.5"} 129389
http_request_duration_seconds_bucket{le="1"} 133988
http_request_duration_seconds_bucket{le="+Inf"} 144320
http_request_duration_seconds_sum 53423
http_request_duration_seconds_count 144320
`),
},
{
name: "summary",
data: []byte(`
# HELP rpc_duration_seconds Telegraf collected metric
# TYPE rpc_duration_seconds summary
rpc_duration_seconds{quantile="0.01"} 3102
rpc_duration_seconds{quantile="0.05"} 3272
rpc_duration_seconds{quantile="0.5"} 4773
rpc_duration_seconds{quantile="0.9"} 9001
rpc_duration_seconds{quantile="0.99"} 76656
rpc_duration_seconds_sum 1.7560473e+07
rpc_duration_seconds_count 2693
`), `),
}, },
} }
ts := httptest.NewServer(http.NotFoundHandler())
defer ts.Close()
url := fmt.Sprintf("http://%s", ts.Listener.Addr())
for _, tt := range tests { for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) { t.Run(tt.name, func(t *testing.T) {
err := tt.output.Init() ts.Config.Handler = http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
require.NoError(t, err) w.WriteHeader(http.StatusOK)
w.Write(tt.data)
})
err = tt.output.Connect() input := &inputs.Prometheus{
URLs: []string{url},
URLTag: "",
MetricVersion: 1,
}
var acc testutil.Accumulator
err := input.Start(&acc)
require.NoError(t, err) require.NoError(t, err)
err = input.Gather(&acc)
require.NoError(t, err)
input.Stop()
metrics := acc.GetTelegrafMetrics()
output := &PrometheusClient{
Listen: "127.0.0.1:0",
Path: defaultPath,
MetricVersion: 1,
Log: Logger,
CollectorsExclude: []string{"gocollector", "process"},
}
err = output.Init()
require.NoError(t, err)
err = output.Connect()
require.NoError(t, err)
defer func() { defer func() {
err := tt.output.Close() err = output.Close()
require.NoError(t, err) require.NoError(t, err)
}() }()
err = output.Write(metrics)
err = tt.output.Write(tt.metrics)
require.NoError(t, err) require.NoError(t, err)
resp, err := http.Get(tt.output.URL()) resp, err := http.Get(output.URL())
require.NoError(t, err) require.NoError(t, err)
require.Equal(t, http.StatusOK, resp.StatusCode)
defer resp.Body.Close() actual, err := ioutil.ReadAll(resp.Body)
body, err := ioutil.ReadAll(resp.Body)
require.NoError(t, err) require.NoError(t, err)
require.Equal(t, require.Equal(t,
strings.TrimSpace(string(tt.expected)), strings.TrimSpace(string(tt.data)),
strings.TrimSpace(string(body))) strings.TrimSpace(string(actual)))
}) })
} }
} }

376
plugins/outputs/prometheus_client/prometheus_client_v2_test.go Normal file
View File

@ -0,0 +1,376 @@
package prometheus
import (
"fmt"
"io/ioutil"
"net/http"
"net/http/httptest"
"strings"
"testing"
"time"
"github.com/influxdata/telegraf"
inputs "github.com/influxdata/telegraf/plugins/inputs/prometheus"
"github.com/influxdata/telegraf/testutil"
"github.com/stretchr/testify/require"
)
func TestMetricVersion2(t *testing.T) {
Logger := testutil.Logger{Name: "outputs.prometheus_client"}
tests := []struct {
name string
output *PrometheusClient
metrics []telegraf.Metric
expected []byte
}{
{
name: "untyped telegraf metric",
output: &PrometheusClient{
Listen: ":0",
MetricVersion: 2,
CollectorsExclude: []string{"gocollector", "process"},
Path: "/metrics",
Log: Logger,
},
metrics: []telegraf.Metric{
testutil.MustMetric(
"cpu",
map[string]string{
"host": "example.org",
},
map[string]interface{}{
"time_idle": 42.0,
},
time.Unix(0, 0),
),
},
expected: []byte(`
# HELP cpu_time_idle Telegraf collected metric
# TYPE cpu_time_idle untyped
cpu_time_idle{host="example.org"} 42
`),
},
{
name: "strings as labels",
output: &PrometheusClient{
Listen: ":0",
MetricVersion: 2,
CollectorsExclude: []string{"gocollector", "process"},
Path: "/metrics",
StringAsLabel: true,
Log: Logger,
},
metrics: []telegraf.Metric{
testutil.MustMetric(
"cpu",
map[string]string{},
map[string]interface{}{
"time_idle": 42.0,
"host": "example.org",
},
time.Unix(0, 0),
),
},
expected: []byte(`
# HELP cpu_time_idle Telegraf collected metric
# TYPE cpu_time_idle untyped
cpu_time_idle{host="example.org"} 42
`),
},
{
name: "when strings as labels is false string fields are discarded",
output: &PrometheusClient{
Listen: ":0",
MetricVersion: 2,
CollectorsExclude: []string{"gocollector", "process"},
Path: "/metrics",
StringAsLabel: false,
Log: Logger,
},
metrics: []telegraf.Metric{
testutil.MustMetric(
"cpu",
map[string]string{},
map[string]interface{}{
"time_idle": 42.0,
"host": "example.org",
},
time.Unix(0, 0),
),
},
expected: []byte(`
# HELP cpu_time_idle Telegraf collected metric
# TYPE cpu_time_idle untyped
cpu_time_idle 42
`),
},
{
name: "untype prometheus metric",
output: &PrometheusClient{
Listen: ":0",
MetricVersion: 2,
CollectorsExclude: []string{"gocollector", "process"},
Path: "/metrics",
Log: Logger,
},
metrics: []telegraf.Metric{
testutil.MustMetric(
"prometheus",
map[string]string{
"host": "example.org",
},
map[string]interface{}{
"cpu_time_idle": 42.0,
},
time.Unix(0, 0),
),
},
expected: []byte(`
# HELP cpu_time_idle Telegraf collected metric
# TYPE cpu_time_idle untyped
cpu_time_idle{host="example.org"} 42
`),
},
{
name: "telegraf histogram",
output: &PrometheusClient{
Listen: ":0",
MetricVersion: 2,
CollectorsExclude: []string{"gocollector", "process"},
Path: "/metrics",
Log: Logger,
},
metrics: []telegraf.Metric{
testutil.MustMetric(
"cpu",
map[string]string{
"cpu": "cpu1",
},
map[string]interface{}{
"usage_idle_sum": 2000.0,
"usage_idle_count": 20.0,
},
time.Unix(0, 0),
telegraf.Histogram,
),
testutil.MustMetric(
"cpu",
map[string]string{
"cpu": "cpu1",
"le": "0.0",
},
map[string]interface{}{
"usage_idle_bucket": 0.0,
},
time.Unix(0, 0),
telegraf.Histogram,
),
testutil.MustMetric(
"cpu",
map[string]string{
"cpu": "cpu1",
"le": "50.0",
},
map[string]interface{}{
"usage_idle_bucket": 7.0,
},
time.Unix(0, 0),
telegraf.Histogram,
),
testutil.MustMetric(
"cpu",
map[string]string{
"cpu": "cpu1",
"le": "100.0",
},
map[string]interface{}{
"usage_idle_bucket": 20.0,
},
time.Unix(0, 0),
telegraf.Histogram,
),
testutil.MustMetric(
"cpu",
map[string]string{
"cpu": "cpu1",
"le": "+Inf",
},
map[string]interface{}{
"usage_idle_bucket": 20.0,
},
time.Unix(0, 0),
telegraf.Histogram,
),
},
expected: []byte(`
# HELP cpu_usage_idle Telegraf collected metric
# TYPE cpu_usage_idle histogram
cpu_usage_idle_bucket{cpu="cpu1",le="0"} 0
cpu_usage_idle_bucket{cpu="cpu1",le="50"} 7
cpu_usage_idle_bucket{cpu="cpu1",le="100"} 20
cpu_usage_idle_bucket{cpu="cpu1",le="+Inf"} 20
cpu_usage_idle_sum{cpu="cpu1"} 2000
cpu_usage_idle_count{cpu="cpu1"} 20
`),
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
err := tt.output.Init()
require.NoError(t, err)
err = tt.output.Connect()
require.NoError(t, err)
defer func() {
err := tt.output.Close()
require.NoError(t, err)
}()
err = tt.output.Write(tt.metrics)
require.NoError(t, err)
resp, err := http.Get(tt.output.URL())
require.NoError(t, err)
require.Equal(t, http.StatusOK, resp.StatusCode)
defer resp.Body.Close()
body, err := ioutil.ReadAll(resp.Body)
require.NoError(t, err)
require.Equal(t,
strings.TrimSpace(string(tt.expected)),
strings.TrimSpace(string(body)))
})
}
}
func TestRoundTripMetricVersion2(t *testing.T) {
Logger := testutil.Logger{Name: "outputs.prometheus_client"}
tests := []struct {
name string
data []byte
}{
{
name: "untyped",
data: []byte(`
# HELP cpu_time_idle Telegraf collected metric
# TYPE cpu_time_idle untyped
cpu_time_idle{host="example.org"} 42
`),
},
{
name: "counter",
data: []byte(`
# HELP cpu_time_idle Telegraf collected metric
# TYPE cpu_time_idle counter
cpu_time_idle{host="example.org"} 42
`),
},
{
name: "gauge",
data: []byte(`
# HELP cpu_time_idle Telegraf collected metric
# TYPE cpu_time_idle gauge
cpu_time_idle{host="example.org"} 42
`),
},
{
name: "multi",
data: []byte(`
# HELP cpu_time_guest Telegraf collected metric
# TYPE cpu_time_guest gauge
cpu_time_guest{host="one.example.org"} 42
cpu_time_guest{host="two.example.org"} 42
# HELP cpu_time_idle Telegraf collected metric
# TYPE cpu_time_idle gauge
cpu_time_idle{host="one.example.org"} 42
cpu_time_idle{host="two.example.org"} 42
`),
},
{
name: "histogram",
data: []byte(`
# HELP http_request_duration_seconds Telegraf collected metric
# TYPE http_request_duration_seconds histogram
http_request_duration_seconds_bucket{le="0.05"} 24054
http_request_duration_seconds_bucket{le="0.1"} 33444
http_request_duration_seconds_bucket{le="0.2"} 100392
http_request_duration_seconds_bucket{le="0.5"} 129389
http_request_duration_seconds_bucket{le="1"} 133988
http_request_duration_seconds_bucket{le="+Inf"} 144320
http_request_duration_seconds_sum 53423
http_request_duration_seconds_count 144320
`),
},
{
name: "summary",
data: []byte(`
# HELP rpc_duration_seconds Telegraf collected metric
# TYPE rpc_duration_seconds summary
rpc_duration_seconds{quantile="0.01"} 3102
rpc_duration_seconds{quantile="0.05"} 3272
rpc_duration_seconds{quantile="0.5"} 4773
rpc_duration_seconds{quantile="0.9"} 9001
rpc_duration_seconds{quantile="0.99"} 76656
rpc_duration_seconds_sum 1.7560473e+07
rpc_duration_seconds_count 2693
`),
},
}
ts := httptest.NewServer(http.NotFoundHandler())
defer ts.Close()
url := fmt.Sprintf("http://%s", ts.Listener.Addr())
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
ts.Config.Handler = http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
w.WriteHeader(http.StatusOK)
w.Write(tt.data)
})
input := &inputs.Prometheus{
URLs: []string{url},
URLTag: "",
MetricVersion: 2,
}
var acc testutil.Accumulator
err := input.Start(&acc)
require.NoError(t, err)
err = input.Gather(&acc)
require.NoError(t, err)
input.Stop()
metrics := acc.GetTelegrafMetrics()
output := &PrometheusClient{
Listen: "127.0.0.1:0",
Path: defaultPath,
MetricVersion: 2,
Log: Logger,
CollectorsExclude: []string{"gocollector", "process"},
}
err = output.Init()
require.NoError(t, err)
err = output.Connect()
require.NoError(t, err)
defer func() {
err = output.Close()
require.NoError(t, err)
}()
err = output.Write(metrics)
require.NoError(t, err)
resp, err := http.Get(output.URL())
require.NoError(t, err)
actual, err := ioutil.ReadAll(resp.Body)
require.NoError(t, err)
require.Equal(t,
strings.TrimSpace(string(tt.data)),
strings.TrimSpace(string(actual)))
})
}
}

30
testutil/accumulator.go
View File

@ -28,6 +28,7 @@ type Metric struct {
Tags map[string]string Tags map[string]string
Fields map[string]interface{} Fields map[string]interface{}
Time time.Time Time time.Time
Type telegraf.ValueType
} }
func (p *Metric) String() string { func (p *Metric) String() string {
@ -75,11 +76,11 @@ func (a *Accumulator) ClearMetrics() {
a.Metrics = make([]*Metric, 0) a.Metrics = make([]*Metric, 0)
} }
// AddFields adds a measurement point with a specified timestamp. func (a *Accumulator) addFields(
func (a *Accumulator) AddFields(
measurement string, measurement string,
fields map[string]interface{},
tags map[string]string, tags map[string]string,
fields map[string]interface{},
tp telegraf.ValueType,
timestamp ...time.Time, timestamp ...time.Time,
) { ) {
a.Lock() a.Lock()
@ -132,18 +133,29 @@ func (a *Accumulator) AddFields(
Fields: fieldsCopy, Fields: fieldsCopy,
Tags: tagsCopy, Tags: tagsCopy,
Time: t, Time: t,
Type: tp,
} }
a.Metrics = append(a.Metrics, p) a.Metrics = append(a.Metrics, p)
} }
// AddFields adds a measurement point with a specified timestamp.
func (a *Accumulator) AddFields(
measurement string,
fields map[string]interface{},
tags map[string]string,
timestamp ...time.Time,
) {
a.addFields(measurement, tags, fields, telegraf.Untyped, timestamp...)
}
func (a *Accumulator) AddCounter( func (a *Accumulator) AddCounter(
measurement string, measurement string,
fields map[string]interface{}, fields map[string]interface{},
tags map[string]string, tags map[string]string,
timestamp ...time.Time, timestamp ...time.Time,
) { ) {
a.AddFields(measurement, fields, tags, timestamp...) a.addFields(measurement, tags, fields, telegraf.Counter, timestamp...)
} }
func (a *Accumulator) AddGauge( func (a *Accumulator) AddGauge(
@ -152,12 +164,12 @@ func (a *Accumulator) AddGauge(
tags map[string]string, tags map[string]string,
timestamp ...time.Time, timestamp ...time.Time,
) { ) {
a.AddFields(measurement, fields, tags, timestamp...) a.addFields(measurement, tags, fields, telegraf.Gauge, timestamp...)
} }
func (a *Accumulator) AddMetrics(metrics []telegraf.Metric) { func (a *Accumulator) AddMetrics(metrics []telegraf.Metric) {
for _, m := range metrics { for _, m := range metrics {
a.AddFields(m.Name(), m.Fields(), m.Tags(), m.Time()) a.addFields(m.Name(), m.Tags(), m.Fields(), m.Type(), m.Time())
} }
} }
@ -167,7 +179,7 @@ func (a *Accumulator) AddSummary(
tags map[string]string, tags map[string]string,
timestamp ...time.Time, timestamp ...time.Time,
) { ) {
a.AddFields(measurement, fields, tags, timestamp...) a.addFields(measurement, tags, fields, telegraf.Summary, timestamp...)
} }
func (a *Accumulator) AddHistogram( func (a *Accumulator) AddHistogram(
@ -176,11 +188,11 @@ func (a *Accumulator) AddHistogram(
tags map[string]string, tags map[string]string,
timestamp ...time.Time, timestamp ...time.Time,
) { ) {
a.AddFields(measurement, fields, tags, timestamp...) a.addFields(measurement, tags, fields, telegraf.Histogram, timestamp...)
} }
func (a *Accumulator) AddMetric(m telegraf.Metric) { func (a *Accumulator) AddMetric(m telegraf.Metric) {
a.AddFields(m.Name(), m.Fields(), m.Tags(), m.Time()) a.addFields(m.Name(), m.Tags(), m.Fields(), m.Type(), m.Time())
} }
func (a *Accumulator) WithTracking(maxTracked int) telegraf.TrackingAccumulator { func (a *Accumulator) WithTracking(maxTracked int) telegraf.TrackingAccumulator {

2
testutil/metric.go
View File

@ -197,7 +197,7 @@ func MustMetric(
} }
func FromTestMetric(met *Metric) telegraf.Metric { func FromTestMetric(met *Metric) telegraf.Metric {
m, err := metric.New(met.Measurement, met.Tags, met.Fields, met.Time) m, err := metric.New(met.Measurement, met.Tags, met.Fields, met.Time, met.Type)
if err != nil { if err != nil {
panic("MustMetric") panic("MustMetric")
} }