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

Implement telegraf's own full metric type

Browse Source 
main reasons behind this:
- make adding/removing tags cheap
- make adding/removing fields cheap
- make parsing cheaper
- make parse -> decorate -> write out bytes metric flow much faster

Refactor serializer to use byte buffer
This commit is contained in:
Cameron Sparr
2016-11-22 12:51:57 +00:00
parent 332f678afb
commit db7a4b24b6
40 changed files with 1376 additions and 398 deletions
Download Patch File Download Diff File Expand all files Collapse all files

5
plugins/aggregators/minmax/minmax_test.go
View File

@@ -5,10 +5,11 @@ import (
"time"
"github.com/influxdata/telegraf"
"github.com/influxdata/telegraf/metric"
"github.com/influxdata/telegraf/testutil"
)
var m1, _ = telegraf.NewMetric("m1",
var m1, _ = metric.New("m1",
map[string]string{"foo": "bar"},
map[string]interface{}{
"a": int64(1),
@@ -24,7 +25,7 @@ var m1, _ = telegraf.NewMetric("m1",
},
time.Now(),
)
var m2, _ = telegraf.NewMetric("m1",
var m2, _ = metric.New("m1",
map[string]string{"foo": "bar"},
map[string]interface{}{
"a": int64(1),

3
plugins/inputs/logparser/grok/grok.go
View File

@@ -13,6 +13,7 @@ import (
"github.com/vjeantet/grok"
"github.com/influxdata/telegraf"
"github.com/influxdata/telegraf/metric"
)
var timeLayouts = map[string]string{
@@ -280,7 +281,7 @@ func (p *Parser) ParseLine(line string) (telegraf.Metric, error) {
}
}
return telegraf.NewMetric(p.Measurement, tags, fields, p.tsModder.tsMod(timestamp))
return metric.New(p.Measurement, tags, fields, p.tsModder.tsMod(timestamp))
}
func (p *Parser) addCustomPatterns(scanner *bufio.Scanner) {

3
plugins/inputs/prometheus/parser.go
View File

@@ -14,6 +14,7 @@ import (
"time"
"github.com/influxdata/telegraf"
"github.com/influxdata/telegraf/metric"
"github.com/matttproud/golang_protobuf_extensions/pbutil"
dto "github.com/prometheus/client_model/go"
@@ -85,7 +86,7 @@ func Parse(buf []byte, header http.Header) ([]telegraf.Metric, error) {
} else {
t = time.Now()
}
metric, err := telegraf.NewMetric(metricName, tags, fields, t)
metric, err := metric.New(metricName, tags, fields, t)
if err == nil {
metrics = append(metrics, metric)
}

43
plugins/inputs/webhooks/github/github_webhooks_models.go
View File

@@ -6,6 +6,7 @@ import (
"time"
"github.com/influxdata/telegraf"
"github.com/influxdata/telegraf/metric"
)
const meas = "github_webhooks"
@@ -106,7 +107,7 @@ func (s CommitCommentEvent) NewMetric() telegraf.Metric {
"commit": s.Comment.Commit,
"comment": s.Comment.Body,
}
m, err := telegraf.NewMetric(meas, t, f, time.Now())
m, err := metric.New(meas, t, f, time.Now())
if err != nil {
log.Fatalf("Failed to create %v event", event)
}
@@ -136,7 +137,7 @@ func (s CreateEvent) NewMetric() telegraf.Metric {
"ref": s.Ref,
"refType": s.RefType,
}
m, err := telegraf.NewMetric(meas, t, f, time.Now())
m, err := metric.New(meas, t, f, time.Now())
if err != nil {
log.Fatalf("Failed to create %v event", event)
}
@@ -166,7 +167,7 @@ func (s DeleteEvent) NewMetric() telegraf.Metric {
"ref": s.Ref,
"refType": s.RefType,
}
m, err := telegraf.NewMetric(meas, t, f, time.Now())
m, err := metric.New(meas, t, f, time.Now())
if err != nil {
log.Fatalf("Failed to create %v event", event)
}
@@ -197,7 +198,7 @@ func (s DeploymentEvent) NewMetric() telegraf.Metric {
"environment": s.Deployment.Environment,
"description": s.Deployment.Description,
}
m, err := telegraf.NewMetric(meas, t, f, time.Now())
m, err := metric.New(meas, t, f, time.Now())
if err != nil {
log.Fatalf("Failed to create %v event", event)
}
@@ -231,7 +232,7 @@ func (s DeploymentStatusEvent) NewMetric() telegraf.Metric {
"depState": s.DeploymentStatus.State,
"depDescription": s.DeploymentStatus.Description,
}
m, err := telegraf.NewMetric(meas, t, f, time.Now())
m, err := metric.New(meas, t, f, time.Now())
if err != nil {
log.Fatalf("Failed to create %v event", event)
}
@@ -259,7 +260,7 @@ func (s ForkEvent) NewMetric() telegraf.Metric {
"issues": s.Repository.Issues,
"fork": s.Forkee.Repository,
}
m, err := telegraf.NewMetric(meas, t, f, time.Now())
m, err := metric.New(meas, t, f, time.Now())
if err != nil {
log.Fatalf("Failed to create %v event", event)
}
@@ -287,7 +288,7 @@ func (s GollumEvent) NewMetric() telegraf.Metric {
"forks": s.Repository.Forks,
"issues": s.Repository.Issues,
}
m, err := telegraf.NewMetric(meas, t, f, time.Now())
m, err := metric.New(meas, t, f, time.Now())
if err != nil {
log.Fatalf("Failed to create %v event", event)
}
@@ -319,7 +320,7 @@ func (s IssueCommentEvent) NewMetric() telegraf.Metric {
"comments": s.Issue.Comments,
"body": s.Comment.Body,
}
m, err := telegraf.NewMetric(meas, t, f, time.Now())
m, err := metric.New(meas, t, f, time.Now())
if err != nil {
log.Fatalf("Failed to create %v event", event)
}
@@ -351,7 +352,7 @@ func (s IssuesEvent) NewMetric() telegraf.Metric {
"title": s.Issue.Title,
"comments": s.Issue.Comments,
}
m, err := telegraf.NewMetric(meas, t, f, time.Now())
m, err := metric.New(meas, t, f, time.Now())
if err != nil {
log.Fatalf("Failed to create %v event", event)
}
@@ -380,7 +381,7 @@ func (s MemberEvent) NewMetric() telegraf.Metric {
"newMember": s.Member.User,
"newMemberStatus": s.Member.Admin,
}
m, err := telegraf.NewMetric(meas, t, f, time.Now())
m, err := metric.New(meas, t, f, time.Now())
if err != nil {
log.Fatalf("Failed to create %v event", event)
}
@@ -406,7 +407,7 @@ func (s MembershipEvent) NewMetric() telegraf.Metric {
"newMember": s.Member.User,
"newMemberStatus": s.Member.Admin,
}
m, err := telegraf.NewMetric(meas, t, f, time.Now())
m, err := metric.New(meas, t, f, time.Now())
if err != nil {
log.Fatalf("Failed to create %v event", event)
}
@@ -432,7 +433,7 @@ func (s PageBuildEvent) NewMetric() telegraf.Metric {
"forks": s.Repository.Forks,
"issues": s.Repository.Issues,
}
m, err := telegraf.NewMetric(meas, t, f, time.Now())
m, err := metric.New(meas, t, f, time.Now())
if err != nil {
log.Fatalf("Failed to create %v event", event)
}
@@ -458,7 +459,7 @@ func (s PublicEvent) NewMetric() telegraf.Metric {
"forks": s.Repository.Forks,
"issues": s.Repository.Issues,
}
m, err := telegraf.NewMetric(meas, t, f, time.Now())
m, err := metric.New(meas, t, f, time.Now())
if err != nil {
log.Fatalf("Failed to create %v event", event)
}
@@ -495,7 +496,7 @@ func (s PullRequestEvent) NewMetric() telegraf.Metric {
"deletions": s.PullRequest.Deletions,
"changedFiles": s.PullRequest.ChangedFiles,
}
m, err := telegraf.NewMetric(meas, t, f, time.Now())
m, err := metric.New(meas, t, f, time.Now())
if err != nil {
log.Fatalf("Failed to create %v event", event)
}
@@ -533,7 +534,7 @@ func (s PullRequestReviewCommentEvent) NewMetric() telegraf.Metric {
"commentFile": s.Comment.File,
"comment": s.Comment.Comment,
}
m, err := telegraf.NewMetric(meas, t, f, time.Now())
m, err := metric.New(meas, t, f, time.Now())
if err != nil {
log.Fatalf("Failed to create %v event", event)
}
@@ -565,7 +566,7 @@ func (s PushEvent) NewMetric() telegraf.Metric {
"before": s.Before,
"after": s.After,
}
m, err := telegraf.NewMetric(meas, t, f, time.Now())
m, err := metric.New(meas, t, f, time.Now())
if err != nil {
log.Fatalf("Failed to create %v event", event)
}
@@ -593,7 +594,7 @@ func (s ReleaseEvent) NewMetric() telegraf.Metric {
"issues": s.Repository.Issues,
"tagName": s.Release.TagName,
}
m, err := telegraf.NewMetric(meas, t, f, time.Now())
m, err := metric.New(meas, t, f, time.Now())
if err != nil {
log.Fatalf("Failed to create %v event", event)
}
@@ -619,7 +620,7 @@ func (s RepositoryEvent) NewMetric() telegraf.Metric {
"forks": s.Repository.Forks,
"issues": s.Repository.Issues,
}
m, err := telegraf.NewMetric(meas, t, f, time.Now())
m, err := metric.New(meas, t, f, time.Now())
if err != nil {
log.Fatalf("Failed to create %v event", event)
}
@@ -649,7 +650,7 @@ func (s StatusEvent) NewMetric() telegraf.Metric {
"commit": s.Commit,
"state": s.State,
}
m, err := telegraf.NewMetric(meas, t, f, time.Now())
m, err := metric.New(meas, t, f, time.Now())
if err != nil {
log.Fatalf("Failed to create %v event", event)
}
@@ -677,7 +678,7 @@ func (s TeamAddEvent) NewMetric() telegraf.Metric {
"issues": s.Repository.Issues,
"teamName": s.Team.Name,
}
m, err := telegraf.NewMetric(meas, t, f, time.Now())
m, err := metric.New(meas, t, f, time.Now())
if err != nil {
log.Fatalf("Failed to create %v event", event)
}
@@ -703,7 +704,7 @@ func (s WatchEvent) NewMetric() telegraf.Metric {
"forks": s.Repository.Forks,
"issues": s.Repository.Issues,
}
m, err := telegraf.NewMetric(meas, t, f, time.Now())
m, err := metric.New(meas, t, f, time.Now())
if err != nil {
log.Fatalf("Failed to create %v event", event)
}

11
plugins/outputs/amqp/amqp.go
View File

@@ -1,7 +1,6 @@
package amqp
import (
"bytes"
"fmt"
"log"
"strings"
@@ -178,7 +177,7 @@ func (q *AMQP) Write(metrics []telegraf.Metric) error {
if len(metrics) == 0 {
return nil
}
var outbuf = make(map[string][][]byte)
outbuf := make(map[string][]byte)
for _, metric := range metrics {
var key string
@@ -188,14 +187,12 @@ func (q *AMQP) Write(metrics []telegraf.Metric) error {
}
}
values, err := q.serializer.Serialize(metric)
buf, err := q.serializer.Serialize(metric)
if err != nil {
return err
}
for _, value := range values {
outbuf[key] = append(outbuf[key], []byte(value))
}
outbuf[key] = append(outbuf[key], buf...)
}
for key, buf := range outbuf {
@@ -207,7 +204,7 @@ func (q *AMQP) Write(metrics []telegraf.Metric) error {
amqp.Publishing{
Headers: q.headers,
ContentType: "text/plain",
Body: bytes.Join(buf, []byte("\n")),
Body: buf,
})
if err != nil {
return fmt.Errorf("FAILED to send amqp message: %s", err)

11
plugins/outputs/file/file.go
View File

@@ -92,16 +92,9 @@ func (f *File) Write(metrics []telegraf.Metric) error {
}
for _, metric := range metrics {
values, err := f.serializer.Serialize(metric)
_, err := f.writer.Write(metric.Serialize())
if err != nil {
return err
}
for _, value := range values {
_, err = f.writer.Write([]byte(value + "\n"))
if err != nil {
return fmt.Errorf("FAILED to write message: %s, %s", value, err)
}
return fmt.Errorf("FAILED to write message: %s, %s", metric.Serialize(), err)
}
}
return nil

10
plugins/outputs/graphite/graphite.go
View File

@@ -5,7 +5,6 @@ import (
"log"
"math/rand"
"net"
"strings"
"time"
"github.com/influxdata/telegraf"
@@ -76,20 +75,19 @@ func (g *Graphite) Description() string {
// occurs, logging each unsuccessful. If all servers fail, return error.
func (g *Graphite) Write(metrics []telegraf.Metric) error {
// Prepare data
var bp []string
var batch []byte
s, err := serializers.NewGraphiteSerializer(g.Prefix, g.Template)
if err != nil {
return err
}
for _, metric := range metrics {
gMetrics, err := s.Serialize(metric)
buf, err := s.Serialize(metric)
if err != nil {
log.Printf("E! Error serializing some metrics to graphite: %s", err.Error())
}
bp = append(bp, gMetrics...)
batch = append(batch, buf...)
}
graphitePoints := strings.Join(bp, "\n") + "\n"
// This will get set to nil if a successful write occurs
err = errors.New("Could not write to any Graphite server in cluster\n")
@@ -100,7 +98,7 @@ func (g *Graphite) Write(metrics []telegraf.Metric) error {
if g.Timeout > 0 {
g.conns[n].SetWriteDeadline(time.Now().Add(time.Duration(g.Timeout) * time.Second))
}
if _, e := g.conns[n].Write([]byte(graphitePoints)); e != nil {
if _, e := g.conns[n].Write(batch); e != nil {
// Error
log.Println("E! Graphite Error: " + e.Error())
// Let's try the next one

9
plugins/outputs/graphite/graphite_test.go
View File

@@ -9,6 +9,7 @@ import (
"time"
"github.com/influxdata/telegraf"
"github.com/influxdata/telegraf/metric"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
@@ -21,7 +22,7 @@ func TestGraphiteError(t *testing.T) {
Prefix: "my.prefix",
}
// Init metrics
m1, _ := telegraf.NewMetric(
m1, _ := metric.New(
"mymeasurement",
map[string]string{"host": "192.168.0.1"},
map[string]interface{}{"mymeasurement": float64(3.14)},
@@ -51,19 +52,19 @@ func TestGraphiteOK(t *testing.T) {
Prefix: "my.prefix",
}
// Init metrics
m1, _ := telegraf.NewMetric(
m1, _ := metric.New(
"mymeasurement",
map[string]string{"host": "192.168.0.1"},
map[string]interface{}{"myfield": float64(3.14)},
time.Date(2010, time.November, 10, 23, 0, 0, 0, time.UTC),
)
m2, _ := telegraf.NewMetric(
m2, _ := 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),
)
m3, _ := telegraf.NewMetric(
m3, _ := metric.New(
"my_measurement",
map[string]string{"host": "192.168.0.1"},
map[string]interface{}{"value": float64(3.14)},

43
plugins/outputs/instrumental/instrumental.go
View File

@@ -1,6 +1,7 @@
package instrumental
import (
"bytes"
"fmt"
"io"
"log"
@@ -10,11 +11,17 @@ import (
"github.com/influxdata/telegraf"
"github.com/influxdata/telegraf/internal"
"github.com/influxdata/telegraf/metric"
"github.com/influxdata/telegraf/plugins/outputs"
"github.com/influxdata/telegraf/plugins/serializers"
"github.com/influxdata/telegraf/plugins/serializers/graphite"
)
var (
ValueIncludesBadChar = regexp.MustCompile("[^[:digit:].]")
MetricNameReplacer = regexp.MustCompile("[^-[:alnum:]_.]+")
)
type Instrumental struct {
Host string
ApiToken string
@@ -34,11 +41,6 @@ const (
HandshakeFormat = HelloMessage + AuthFormat
)
var (
ValueIncludesBadChar = regexp.MustCompile("[^[:digit:].]")
MetricNameReplacer = regexp.MustCompile("[^-[:alnum:]_.]+")
)
var sampleConfig = `
## Project API Token (required)
api_token = "API Token" # required
@@ -94,7 +96,7 @@ func (i *Instrumental) Write(metrics []telegraf.Metric) error {
var toSerialize telegraf.Metric
var newTags map[string]string
for _, metric := range metrics {
for _, m := range metrics {
// Pull the metric_type out of the metric's tags. We don't want the type
// to show up with the other tags pulled from the system, as they go in the
// beginning of the line instead.
@@ -106,18 +108,18 @@ func (i *Instrumental) Write(metrics []telegraf.Metric) error {
//
// increment some_prefix.host.tag1.tag2.tag3.counter.field value timestamp
//
newTags = metric.Tags()
newTags = m.Tags()
metricType = newTags["metric_type"]
delete(newTags, "metric_type")
toSerialize, _ = telegraf.NewMetric(
metric.Name(),
toSerialize, _ = metric.New(
m.Name(),
newTags,
metric.Fields(),
metric.Time(),
m.Fields(),
m.Time(),
)
stats, err := s.Serialize(toSerialize)
buf, err := s.Serialize(toSerialize)
if err != nil {
log.Printf("E! Error serializing a metric to Instrumental: %s", err)
}
@@ -131,20 +133,25 @@ func (i *Instrumental) Write(metrics []telegraf.Metric) error {
metricType = "gauge"
}
for _, stat := range stats {
buffer := bytes.NewBuffer(buf)
for {
line, err := buffer.ReadBytes('\n')
if err != nil {
break
}
stat := string(line)
// decompose "metric.name value time"
splitStat := strings.SplitN(stat, " ", 3)
metric := splitStat[0]
name := splitStat[0]
value := splitStat[1]
time := splitStat[2]
// replace invalid components of metric name with underscore
clean_metric := MetricNameReplacer.ReplaceAllString(metric, "_")
clean_metric := MetricNameReplacer.ReplaceAllString(name, "_")
if !ValueIncludesBadChar.MatchString(value) {
points = append(points, fmt.Sprintf("%s %s %s %s", metricType, clean_metric, value, time))
} else if i.Debug {
log.Printf("E! Instrumental unable to send bad stat: %s", stat)
}
}
}
@@ -152,8 +159,6 @@ func (i *Instrumental) Write(metrics []telegraf.Metric) error {
allPoints := strings.Join(points, "\n") + "\n"
_, err = fmt.Fprintf(i.conn, allPoints)
log.Println("D! Instrumental: " + allPoints)
if err != nil {
if err == io.EOF {
i.Close()

13
plugins/outputs/instrumental/instrumental_test.go
View File

@@ -9,6 +9,7 @@ import (
"time"
"github.com/influxdata/telegraf"
"github.com/influxdata/telegraf/metric"
"github.com/stretchr/testify/assert"
)
@@ -26,13 +27,13 @@ func TestWrite(t *testing.T) {
}
// Default to gauge
m1, _ := telegraf.NewMetric(
m1, _ := metric.New(
"mymeasurement",
map[string]string{"host": "192.168.0.1"},
map[string]interface{}{"myfield": float64(3.14)},
time.Date(2010, time.November, 10, 23, 0, 0, 0, time.UTC),
)
m2, _ := telegraf.NewMetric(
m2, _ := metric.New(
"mymeasurement",
map[string]string{"host": "192.168.0.1", "metric_type": "set"},
map[string]interface{}{"value": float64(3.14)},
@@ -43,27 +44,27 @@ func TestWrite(t *testing.T) {
i.Write(metrics)
// Counter and Histogram are increments
m3, _ := telegraf.NewMetric(
m3, _ := metric.New(
"my_histogram",
map[string]string{"host": "192.168.0.1", "metric_type": "histogram"},
map[string]interface{}{"value": float64(3.14)},
time.Date(2010, time.November, 10, 23, 0, 0, 0, time.UTC),
)
// We will modify metric names that won't be accepted by Instrumental
m4, _ := telegraf.NewMetric(
m4, _ := metric.New(
"bad_metric_name",
map[string]string{"host": "192.168.0.1:8888::123", "metric_type": "counter"},
map[string]interface{}{"value": 1},
time.Date(2010, time.November, 10, 23, 0, 0, 0, time.UTC),
)
// We will drop metric values that won't be accepted by Instrumental
m5, _ := telegraf.NewMetric(
m5, _ := metric.New(
"bad_values",
map[string]string{"host": "192.168.0.1", "metric_type": "counter"},
map[string]interface{}{"value": "\" 3:30\""},
time.Date(2010, time.November, 10, 23, 0, 0, 0, time.UTC),
)
m6, _ := telegraf.NewMetric(
m6, _ := metric.New(
"my_counter",
map[string]string{"host": "192.168.0.1", "metric_type": "counter"},
map[string]interface{}{"value": float64(3.14)},

11
plugins/outputs/librato/librato_test.go
View File

@@ -9,6 +9,7 @@ import (
"time"
"github.com/influxdata/telegraf"
"github.com/influxdata/telegraf/metric"
"github.com/stretchr/testify/require"
)
@@ -163,7 +164,7 @@ func TestBuildGauge(t *testing.T) {
}
func newHostMetric(value interface{}, name, host string) (metric telegraf.Metric) {
metric, _ = telegraf.NewMetric(
metric, _ = metric.New(
name,
map[string]string{"host": host},
map[string]interface{}{"value": value},
@@ -174,19 +175,19 @@ func newHostMetric(value interface{}, name, host string) (metric telegraf.Metric
func TestBuildGaugeWithSource(t *testing.T) {
mtime := time.Date(2009, time.November, 10, 23, 0, 0, 0, time.UTC)
pt1, _ := telegraf.NewMetric(
pt1, _ := metric.New(
"test1",
map[string]string{"hostname": "192.168.0.1", "tag1": "value1"},
map[string]interface{}{"value": 0.0},
mtime,
)
pt2, _ := telegraf.NewMetric(
pt2, _ := metric.New(
"test2",
map[string]string{"hostnam": "192.168.0.1", "tag1": "value1"},
map[string]interface{}{"value": 1.0},
mtime,
)
pt3, _ := telegraf.NewMetric(
pt3, _ := metric.New(
"test3",
map[string]string{
"hostname": "192.168.0.1",
@@ -195,7 +196,7 @@ func TestBuildGaugeWithSource(t *testing.T) {
map[string]interface{}{"value": 1.0},
mtime,
)
pt4, _ := telegraf.NewMetric(
pt4, _ := metric.New(
"test4",
map[string]string{
"hostname": "192.168.0.1",

12
plugins/outputs/mqtt/mqtt.go
View File

@@ -128,24 +128,22 @@ func (m *MQTT) Write(metrics []telegraf.Metric) error {
t = append(t, metric.Name())
topic := strings.Join(t, "/")
values, err := m.serializer.Serialize(metric)
buf, err := m.serializer.Serialize(metric)
if err != nil {
return fmt.Errorf("MQTT Could not serialize metric: %s",
metric.String())
}
for _, value := range values {
err = m.publish(topic, value)
if err != nil {
return fmt.Errorf("Could not write to MQTT server, %s", err)
}
err = m.publish(topic, buf)
if err != nil {
return fmt.Errorf("Could not write to MQTT server, %s", err)
}
}
return nil
}
func (m *MQTT) publish(topic, body string) error {
func (m *MQTT) publish(topic string, body []byte) error {
token := m.client.Publish(topic, byte(m.QoS), false, body)
token.Wait()
if token.Error() != nil {

13
plugins/outputs/nats/nats.go
View File

@@ -115,20 +115,13 @@ func (n *NATS) Write(metrics []telegraf.Metric) error {
}
for _, metric := range metrics {
values, err := n.serializer.Serialize(metric)
buf, err := n.serializer.Serialize(metric)
if err != nil {
return err
}
var pubErr error
for _, value := range values {
err = n.conn.Publish(n.Subject, []byte(value))
if err != nil {
pubErr = err
}
}
if pubErr != nil {
err = n.conn.Publish(n.Subject, buf)
if err != nil {
return fmt.Errorf("FAILED to send NATS message: %s", err)
}
}

13
plugins/outputs/nsq/nsq.go
View File

@@ -66,20 +66,13 @@ func (n *NSQ) Write(metrics []telegraf.Metric) error {
}
for _, metric := range metrics {
values, err := n.serializer.Serialize(metric)
buf, err := n.serializer.Serialize(metric)
if err != nil {
return err
}
var pubErr error
for _, value := range values {
err = n.producer.Publish(n.Topic, []byte(value))
if err != nil {
pubErr = err
}
}
if pubErr != nil {
err = n.producer.Publish(n.Topic, buf)
if err != nil {
return fmt.Errorf("FAILED to send NSQD message: %s", err)
}
}

13
plugins/outputs/prometheus_client/prometheus_client_test.go
View File

@@ -9,6 +9,7 @@ import (
"github.com/influxdata/telegraf"
"github.com/influxdata/telegraf/internal"
"github.com/influxdata/telegraf/metric"
"github.com/influxdata/telegraf/plugins/inputs/prometheus"
"github.com/influxdata/telegraf/testutil"
)
@@ -26,12 +27,12 @@ func TestPrometheusWritePointEmptyTag(t *testing.T) {
now := time.Now()
tags := make(map[string]string)
pt1, _ := telegraf.NewMetric(
pt1, _ := metric.New(
"test_point_1",
tags,
map[string]interface{}{"value": 0.0},
now)
pt2, _ := telegraf.NewMetric(
pt2, _ := metric.New(
"test_point_2",
tags,
map[string]interface{}{"value": 1.0},
@@ -61,12 +62,12 @@ func TestPrometheusWritePointEmptyTag(t *testing.T) {
tags = make(map[string]string)
tags["testtag"] = "testvalue"
pt3, _ := telegraf.NewMetric(
pt3, _ := metric.New(
"test_point_3",
tags,
map[string]interface{}{"value": 0.0},
now)
pt4, _ := telegraf.NewMetric(
pt4, _ := metric.New(
"test_point_4",
tags,
map[string]interface{}{"value": 1.0},
@@ -104,7 +105,7 @@ func TestPrometheusExpireOldMetrics(t *testing.T) {
now := time.Now()
tags := make(map[string]string)
pt1, _ := telegraf.NewMetric(
pt1, _ := metric.New(
"test_point_1",
tags,
map[string]interface{}{"value": 0.0},
@@ -116,7 +117,7 @@ func TestPrometheusExpireOldMetrics(t *testing.T) {
m.Expiration = now.Add(time.Duration(-15) * time.Second)
}
pt2, _ := telegraf.NewMetric(
pt2, _ := metric.New(
"test_point_2",
tags,
map[string]interface{}{"value": 1.0},

3
plugins/parsers/graphite/parser.go
View File

@@ -12,6 +12,7 @@ import (
"time"
"github.com/influxdata/telegraf"
"github.com/influxdata/telegraf/metric"
)
// Minimum and maximum supported dates for timestamps.
@@ -216,7 +217,7 @@ func (p *GraphiteParser) ParseLine(line string) (telegraf.Metric, error) {
}
}
return telegraf.NewMetric(measurement, tags, fieldValues, timestamp)
return metric.New(measurement, tags, fieldValues, timestamp)
}
// ApplyTemplate extracts the template fields from the given line and

27
plugins/parsers/graphite/parser_test.go
View File

@@ -7,6 +7,7 @@ import (
"time"
"github.com/influxdata/telegraf"
"github.com/influxdata/telegraf/metric"
"github.com/stretchr/testify/assert"
)
@@ -369,7 +370,7 @@ func TestFilterMatchDefault(t *testing.T) {
t.Fatalf("unexpected error creating parser, got %v", err)
}
exp, err := telegraf.NewMetric("miss.servers.localhost.cpu_load",
exp, err := metric.New("miss.servers.localhost.cpu_load",
map[string]string{},
map[string]interface{}{"value": float64(11)},
time.Unix(1435077219, 0))
@@ -387,7 +388,7 @@ func TestFilterMatchMultipleMeasurement(t *testing.T) {
t.Fatalf("unexpected error creating parser, got %v", err)
}
exp, err := telegraf.NewMetric("cpu.cpu_load.10",
exp, err := metric.New("cpu.cpu_load.10",
map[string]string{"host": "localhost"},
map[string]interface{}{"value": float64(11)},
time.Unix(1435077219, 0))
@@ -406,7 +407,7 @@ func TestFilterMatchMultipleMeasurementSeparator(t *testing.T) {
)
assert.NoError(t, err)
exp, err := telegraf.NewMetric("cpu_cpu_load_10",
exp, err := metric.New("cpu_cpu_load_10",
map[string]string{"host": "localhost"},
map[string]interface{}{"value": float64(11)},
time.Unix(1435077219, 0))
@@ -424,7 +425,7 @@ func TestFilterMatchSingle(t *testing.T) {
t.Fatalf("unexpected error creating parser, got %v", err)
}
exp, err := telegraf.NewMetric("cpu_load",
exp, err := metric.New("cpu_load",
map[string]string{"host": "localhost"},
map[string]interface{}{"value": float64(11)},
time.Unix(1435077219, 0))
@@ -441,7 +442,7 @@ func TestParseNoMatch(t *testing.T) {
t.Fatalf("unexpected error creating parser, got %v", err)
}
exp, err := telegraf.NewMetric("servers.localhost.memory.VmallocChunk",
exp, err := metric.New("servers.localhost.memory.VmallocChunk",
map[string]string{},
map[string]interface{}{"value": float64(11)},
time.Unix(1435077219, 0))
@@ -459,7 +460,7 @@ func TestFilterMatchWildcard(t *testing.T) {
t.Fatalf("unexpected error creating parser, got %v", err)
}
exp, err := telegraf.NewMetric("cpu_load",
exp, err := metric.New("cpu_load",
map[string]string{"host": "localhost"},
map[string]interface{}{"value": float64(11)},
time.Unix(1435077219, 0))
@@ -479,7 +480,7 @@ func TestFilterMatchExactBeforeWildcard(t *testing.T) {
t.Fatalf("unexpected error creating parser, got %v", err)
}
exp, err := telegraf.NewMetric("cpu_load",
exp, err := metric.New("cpu_load",
map[string]string{"host": "localhost"},
map[string]interface{}{"value": float64(11)},
time.Unix(1435077219, 0))
@@ -504,7 +505,7 @@ func TestFilterMatchMostLongestFilter(t *testing.T) {
t.Fatalf("unexpected error creating parser, got %v", err)
}
exp, err := telegraf.NewMetric("cpu_load",
exp, err := metric.New("cpu_load",
map[string]string{"host": "localhost", "resource": "cpu"},
map[string]interface{}{"value": float64(11)},
time.Unix(1435077219, 0))
@@ -528,7 +529,7 @@ func TestFilterMatchMultipleWildcards(t *testing.T) {
t.Fatalf("unexpected error creating parser, got %v", err)
}
exp, err := telegraf.NewMetric("cpu_load",
exp, err := metric.New("cpu_load",
map[string]string{"host": "server01"},
map[string]interface{}{"value": float64(11)},
time.Unix(1435077219, 0))
@@ -550,7 +551,7 @@ func TestParseDefaultTags(t *testing.T) {
t.Fatalf("unexpected error creating parser, got %v", err)
}
exp, err := telegraf.NewMetric("cpu_load",
exp, err := metric.New("cpu_load",
map[string]string{"host": "localhost", "region": "us-east", "zone": "1c"},
map[string]interface{}{"value": float64(11)},
time.Unix(1435077219, 0))
@@ -571,7 +572,7 @@ func TestParseDefaultTemplateTags(t *testing.T) {
t.Fatalf("unexpected error creating parser, got %v", err)
}
exp, err := telegraf.NewMetric("cpu_load",
exp, err := metric.New("cpu_load",
map[string]string{"host": "localhost", "region": "us-east", "zone": "1c"},
map[string]interface{}{"value": float64(11)},
time.Unix(1435077219, 0))
@@ -592,7 +593,7 @@ func TestParseDefaultTemplateTagsOverridGlobal(t *testing.T) {
t.Fatalf("unexpected error creating parser, got %v", err)
}
exp, err := telegraf.NewMetric("cpu_load",
exp, err := metric.New("cpu_load",
map[string]string{"host": "localhost", "region": "us-east", "zone": "1c"},
map[string]interface{}{"value": float64(11)},
time.Unix(1435077219, 0))
@@ -615,7 +616,7 @@ func TestParseTemplateWhitespace(t *testing.T) {
t.Fatalf("unexpected error creating parser, got %v", err)
}
exp, err := telegraf.NewMetric("cpu_load",
exp, err := metric.New("cpu_load",
map[string]string{"host": "localhost", "region": "us-east", "zone": "1c"},
map[string]interface{}{"value": float64(11)},
time.Unix(1435077219, 0))

21
plugins/parsers/influx/parser.go
View File

@@ -6,8 +6,7 @@ import (
"time"
"github.com/influxdata/telegraf"
"github.com/influxdata/influxdb/models"
"github.com/influxdata/telegraf/metric"
)
// InfluxParser is an object for Parsing incoming metrics.
@@ -19,18 +18,16 @@ type InfluxParser struct {
func (p *InfluxParser) ParseWithDefaultTime(buf []byte, t time.Time) ([]telegraf.Metric, error) {
// parse even if the buffer begins with a newline
buf = bytes.TrimPrefix(buf, []byte("\n"))
points, err := models.ParsePointsWithPrecision(buf, t, "n")
metrics := make([]telegraf.Metric, len(points))
for i, point := range points {
for k, v := range p.DefaultTags {
// only set the default tag if it doesn't already exist:
if tmp := point.Tags().GetString(k); tmp == "" {
point.AddTag(k, v)
metrics, err := metric.ParseWithDefaultTime(buf, t)
if len(p.DefaultTags) > 0 {
for _, m := range metrics {
for k, v := range p.DefaultTags {
// only set the default tag if it doesn't already exist:
if !m.HasTag(k) {
m.AddTag(k, v)
}
}
}
// Ignore error here because it's impossible that a model.Point
// wouldn't parse into client.Point properly
metrics[i] = telegraf.NewMetricFromPoint(point)
}
return metrics, err
}

24
plugins/parsers/influx/parser_test.go
View File

@@ -14,15 +14,14 @@ var (
ms []telegraf.Metric
writer = ioutil.Discard
metrics500 []byte
exptime = time.Date(2009, time.November, 10, 23, 0, 0, 0, time.UTC).UnixNano()
)
var exptime = time.Date(2009, time.November, 10, 23, 0, 0, 0, time.UTC)
const (
validInflux = "cpu_load_short,cpu=cpu0 value=10 1257894000000000000"
validInflux = "cpu_load_short,cpu=cpu0 value=10 1257894000000000000\n"
validInfluxNewline = "\ncpu_load_short,cpu=cpu0 value=10 1257894000000000000\n"
invalidInflux = "I don't think this is line protocol"
invalidInflux2 = "{\"a\": 5, \"b\": {\"c\": 6}}"
invalidInflux = "I don't think this is line protocol\n"
invalidInflux2 = "{\"a\": 5, \"b\": {\"c\": 6}}\n"
)
const influxMulti = `
@@ -57,7 +56,7 @@ func TestParseValidInflux(t *testing.T) {
assert.Equal(t, map[string]string{
"cpu": "cpu0",
}, metrics[0].Tags())
assert.Equal(t, exptime, metrics[0].Time())
assert.Equal(t, exptime, metrics[0].Time().UnixNano())
metrics, err = parser.Parse([]byte(validInfluxNewline))
assert.NoError(t, err)
@@ -69,7 +68,7 @@ func TestParseValidInflux(t *testing.T) {
assert.Equal(t, map[string]string{
"cpu": "cpu0",
}, metrics[0].Tags())
assert.Equal(t, exptime, metrics[0].Time())
assert.Equal(t, exptime, metrics[0].Time().UnixNano())
}
func TestParseLineValidInflux(t *testing.T) {
@@ -84,7 +83,7 @@ func TestParseLineValidInflux(t *testing.T) {
assert.Equal(t, map[string]string{
"cpu": "cpu0",
}, metric.Tags())
assert.Equal(t, exptime, metric.Time())
assert.Equal(t, exptime, metric.Time().UnixNano())
metric, err = parser.ParseLine(validInfluxNewline)
assert.NoError(t, err)
@@ -95,7 +94,7 @@ func TestParseLineValidInflux(t *testing.T) {
assert.Equal(t, map[string]string{
"cpu": "cpu0",
}, metric.Tags())
assert.Equal(t, exptime, metric.Time())
assert.Equal(t, exptime, metric.Time().UnixNano())
}
func TestParseMultipleValid(t *testing.T) {
@@ -229,11 +228,8 @@ func BenchmarkParseAddTagWrite(b *testing.B) {
panic("500 metrics not parsed!!")
}
for _, tmp := range ms {
tags := tmp.Tags()
tags["host"] = "localhost"
tmp, _ = telegraf.NewMetric(tmp.Name(), tags, tmp.Fields(), tmp.Time())
writer.Write([]byte(tmp.String()))
writer.Write([]byte{'\n'})
tmp.AddTag("host", "localhost")
writer.Write(tmp.Serialize())
}
}
}

3
plugins/parsers/json/parser.go
View File

@@ -9,6 +9,7 @@ import (
"time"
"github.com/influxdata/telegraf"
"github.com/influxdata/telegraf/metric"
)
type JSONParser struct {
@@ -57,7 +58,7 @@ func (p *JSONParser) parseObject(metrics []telegraf.Metric, jsonOut map[string]i
return nil, err
}
metric, err := telegraf.NewMetric(p.MetricName, tags, f.Fields, time.Now().UTC())
metric, err := metric.New(p.MetricName, tags, f.Fields, time.Now().UTC())
if err != nil {
return nil, err

3
plugins/parsers/nagios/parser.go
View File

@@ -6,6 +6,7 @@ import (
"time"
"github.com/influxdata/telegraf"
"github.com/influxdata/telegraf/metric"
)
type NagiosParser struct {
@@ -90,7 +91,7 @@ func (p *NagiosParser) Parse(buf []byte) ([]telegraf.Metric, error) {
fields["max"] = perf[0][7]
}
// Create metric
metric, err := telegraf.NewMetric(fieldName, tags, fields, time.Now().UTC())
metric, err := metric.New(fieldName, tags, fields, time.Now().UTC())
if err != nil {
return nil, err
}

3
plugins/parsers/value/parser.go
View File

@@ -8,6 +8,7 @@ import (
"time"
"github.com/influxdata/telegraf"
"github.com/influxdata/telegraf/metric"
)
type ValueParser struct {
@@ -46,7 +47,7 @@ func (v *ValueParser) Parse(buf []byte) ([]telegraf.Metric, error) {
}
fields := map[string]interface{}{"value": value}
metric, err := telegraf.NewMetric(v.MetricName, v.DefaultTags,
metric, err := metric.New(v.MetricName, v.DefaultTags,
fields, time.Now().UTC())
if err != nil {
return nil, err

10
plugins/serializers/graphite/graphite.go
View File

@@ -20,8 +20,8 @@ type GraphiteSerializer struct {
Template string
}
func (s *GraphiteSerializer) Serialize(metric telegraf.Metric) ([]string, error) {
out := []string{}
func (s *GraphiteSerializer) Serialize(metric telegraf.Metric) ([]byte, error) {
out := []byte{}
// Convert UnixNano to Unix timestamps
timestamp := metric.UnixNano() / 1000000000
@@ -34,12 +34,12 @@ func (s *GraphiteSerializer) Serialize(metric telegraf.Metric) ([]string, error)
for fieldName, value := range metric.Fields() {
// Convert value to string
valueS := fmt.Sprintf("%#v", value)
point := fmt.Sprintf("%s %s %d",
point := []byte(fmt.Sprintf("%s %s %d\n",
// insert "field" section of template
sanitizedChars.Replace(InsertField(bucket, fieldName)),
sanitizedChars.Replace(valueS),
timestamp)
out = append(out, point)
timestamp))
out = append(out, point...)
}
return out, nil
}

41
plugins/serializers/graphite/graphite_test.go
View File

@@ -9,6 +9,7 @@ import (
"github.com/stretchr/testify/assert"
"github.com/influxdata/telegraf"
"github.com/influxdata/telegraf/metric"
)
var defaultTags = map[string]string{
@@ -29,19 +30,19 @@ const (
)
func TestGraphiteTags(t *testing.T) {
m1, _ := telegraf.NewMetric(
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, _ := telegraf.NewMetric(
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, _ := telegraf.NewMetric(
m3, _ := metric.New(
"mymeasurement",
map[string]string{"afoo": "first", "bfoo": "second"},
map[string]interface{}{"value": float64(3.14)},
@@ -67,7 +68,7 @@ func TestSerializeMetricNoHost(t *testing.T) {
"usage_idle": float64(91.5),
"usage_busy": float64(8.5),
}
m, err := telegraf.NewMetric("cpu", tags, fields, now)
m, err := metric.New("cpu", tags, fields, now)
assert.NoError(t, err)
s := GraphiteSerializer{}
@@ -94,7 +95,7 @@ func TestSerializeMetricHost(t *testing.T) {
"usage_idle": float64(91.5),
"usage_busy": float64(8.5),
}
m, err := telegraf.NewMetric("cpu", tags, fields, now)
m, err := metric.New("cpu", tags, fields, now)
assert.NoError(t, err)
s := GraphiteSerializer{}
@@ -121,7 +122,7 @@ func TestSerializeValueField(t *testing.T) {
fields := map[string]interface{}{
"value": float64(91.5),
}
m, err := telegraf.NewMetric("cpu", tags, fields, now)
m, err := metric.New("cpu", tags, fields, now)
assert.NoError(t, err)
s := GraphiteSerializer{}
@@ -145,7 +146,7 @@ func TestSerializeValueField2(t *testing.T) {
fields := map[string]interface{}{
"value": float64(91.5),
}
m, err := telegraf.NewMetric("cpu", tags, fields, now)
m, err := metric.New("cpu", tags, fields, now)
assert.NoError(t, err)
s := GraphiteSerializer{
@@ -171,7 +172,7 @@ func TestSerializeFieldWithSpaces(t *testing.T) {
fields := map[string]interface{}{
`field\ with\ spaces`: float64(91.5),
}
m, err := telegraf.NewMetric("cpu", tags, fields, now)
m, err := metric.New("cpu", tags, fields, now)
assert.NoError(t, err)
s := GraphiteSerializer{
@@ -197,7 +198,7 @@ func TestSerializeTagWithSpaces(t *testing.T) {
fields := map[string]interface{}{
`field_with_spaces`: float64(91.5),
}
m, err := telegraf.NewMetric("cpu", tags, fields, now)
m, err := metric.New("cpu", tags, fields, now)
assert.NoError(t, err)
s := GraphiteSerializer{
@@ -223,7 +224,7 @@ func TestSerializeValueField3(t *testing.T) {
fields := map[string]interface{}{
"value": float64(91.5),
}
m, err := telegraf.NewMetric("cpu", tags, fields, now)
m, err := metric.New("cpu", tags, fields, now)
assert.NoError(t, err)
s := GraphiteSerializer{
@@ -249,7 +250,7 @@ func TestSerializeValueField5(t *testing.T) {
fields := map[string]interface{}{
"value": float64(91.5),
}
m, err := telegraf.NewMetric("cpu", tags, fields, now)
m, err := metric.New("cpu", tags, fields, now)
assert.NoError(t, err)
s := GraphiteSerializer{
@@ -275,7 +276,7 @@ func TestSerializeMetricPrefix(t *testing.T) {
"usage_idle": float64(91.5),
"usage_busy": float64(8.5),
}
m, err := telegraf.NewMetric("cpu", tags, fields, now)
m, err := metric.New("cpu", tags, fields, now)
assert.NoError(t, err)
s := GraphiteSerializer{Prefix: "prefix"}
@@ -300,7 +301,7 @@ func TestSerializeBucketNameNoHost(t *testing.T) {
fields := map[string]interface{}{
"usage_idle": float64(91.5),
}
m, err := telegraf.NewMetric("cpu", tags, fields, now)
m, err := metric.New("cpu", tags, fields, now)
assert.NoError(t, err)
mS := SerializeBucketName(m.Name(), m.Tags(), "", "")
@@ -314,7 +315,7 @@ func TestSerializeBucketNameHost(t *testing.T) {
fields := map[string]interface{}{
"usage_idle": float64(91.5),
}
m, err := telegraf.NewMetric("cpu", defaultTags, fields, now)
m, err := metric.New("cpu", defaultTags, fields, now)
assert.NoError(t, err)
mS := SerializeBucketName(m.Name(), m.Tags(), "", "")
@@ -328,7 +329,7 @@ func TestSerializeBucketNamePrefix(t *testing.T) {
fields := map[string]interface{}{
"usage_idle": float64(91.5),
}
m, err := telegraf.NewMetric("cpu", defaultTags, fields, now)
m, err := metric.New("cpu", defaultTags, fields, now)
assert.NoError(t, err)
mS := SerializeBucketName(m.Name(), m.Tags(), "", "prefix")
@@ -342,7 +343,7 @@ func TestTemplate1(t *testing.T) {
fields := map[string]interface{}{
"usage_idle": float64(91.5),
}
m, err := telegraf.NewMetric("cpu", defaultTags, fields, now)
m, err := metric.New("cpu", defaultTags, fields, now)
assert.NoError(t, err)
mS := SerializeBucketName(m.Name(), m.Tags(), template1, "")
@@ -356,7 +357,7 @@ func TestTemplate2(t *testing.T) {
fields := map[string]interface{}{
"usage_idle": float64(91.5),
}
m, err := telegraf.NewMetric("cpu", defaultTags, fields, now)
m, err := metric.New("cpu", defaultTags, fields, now)
assert.NoError(t, err)
mS := SerializeBucketName(m.Name(), m.Tags(), template2, "")
@@ -370,7 +371,7 @@ func TestTemplate3(t *testing.T) {
fields := map[string]interface{}{
"usage_idle": float64(91.5),
}
m, err := telegraf.NewMetric("cpu", defaultTags, fields, now)
m, err := metric.New("cpu", defaultTags, fields, now)
assert.NoError(t, err)
mS := SerializeBucketName(m.Name(), m.Tags(), template3, "")
@@ -384,7 +385,7 @@ func TestTemplate4(t *testing.T) {
fields := map[string]interface{}{
"usage_idle": float64(91.5),
}
m, err := telegraf.NewMetric("cpu", defaultTags, fields, now)
m, err := metric.New("cpu", defaultTags, fields, now)
assert.NoError(t, err)
mS := SerializeBucketName(m.Name(), m.Tags(), template4, "")
@@ -398,7 +399,7 @@ func TestTemplate6(t *testing.T) {
fields := map[string]interface{}{
"usage_idle": float64(91.5),
}
m, err := telegraf.NewMetric("cpu", defaultTags, fields, now)
m, err := metric.New("cpu", defaultTags, fields, now)
assert.NoError(t, err)
mS := SerializeBucketName(m.Name(), m.Tags(), template6, "")

4
plugins/serializers/influx/influx.go
View File

@@ -7,6 +7,6 @@ import (
type InfluxSerializer struct {
}
func (s *InfluxSerializer) Serialize(metric telegraf.Metric) ([]string, error) {
return []string{metric.String()}, nil
func (s *InfluxSerializer) Serialize(metric telegraf.Metric) ([]byte, error) {
return metric.Serialize(), nil
}

7
plugins/serializers/influx/influx_test.go
View File

@@ -8,6 +8,7 @@ import (
"github.com/stretchr/testify/assert"
"github.com/influxdata/telegraf"
"github.com/influxdata/telegraf/metric"
)
func TestSerializeMetricFloat(t *testing.T) {
@@ -18,7 +19,7 @@ func TestSerializeMetricFloat(t *testing.T) {
fields := map[string]interface{}{
"usage_idle": float64(91.5),
}
m, err := telegraf.NewMetric("cpu", tags, fields, now)
m, err := metric.New("cpu", tags, fields, now)
assert.NoError(t, err)
s := InfluxSerializer{}
@@ -37,7 +38,7 @@ func TestSerializeMetricInt(t *testing.T) {
fields := map[string]interface{}{
"usage_idle": int64(90),
}
m, err := telegraf.NewMetric("cpu", tags, fields, now)
m, err := metric.New("cpu", tags, fields, now)
assert.NoError(t, err)
s := InfluxSerializer{}
@@ -56,7 +57,7 @@ func TestSerializeMetricString(t *testing.T) {
fields := map[string]interface{}{
"usage_idle": "foobar",
}
m, err := telegraf.NewMetric("cpu", tags, fields, now)
m, err := metric.New("cpu", tags, fields, now)
assert.NoError(t, err)
s := InfluxSerializer{}

10
plugins/serializers/json/json.go
View File

@@ -9,9 +9,7 @@ import (
type JsonSerializer struct {
}
func (s *JsonSerializer) Serialize(metric telegraf.Metric) ([]string, error) {
out := []string{}
func (s *JsonSerializer) Serialize(metric telegraf.Metric) ([]byte, error) {
m := make(map[string]interface{})
m["tags"] = metric.Tags()
m["fields"] = metric.Fields()
@@ -19,9 +17,9 @@ func (s *JsonSerializer) Serialize(metric telegraf.Metric) ([]string, error) {
m["timestamp"] = metric.UnixNano() / 1000000000
serialized, err := ejson.Marshal(m)
if err != nil {
return []string{}, err
return []byte{}, err
}
out = append(out, string(serialized))
serialized = append(serialized, '\n')
return out, nil
return serialized, nil
}

9
plugins/serializers/json/json_test.go
View File

@@ -8,6 +8,7 @@ import (
"github.com/stretchr/testify/assert"
"github.com/influxdata/telegraf"
"github.com/influxdata/telegraf/metric"
)
func TestSerializeMetricFloat(t *testing.T) {
@@ -18,7 +19,7 @@ func TestSerializeMetricFloat(t *testing.T) {
fields := map[string]interface{}{
"usage_idle": float64(91.5),
}
m, err := telegraf.NewMetric("cpu", tags, fields, now)
m, err := metric.New("cpu", tags, fields, now)
assert.NoError(t, err)
s := JsonSerializer{}
@@ -36,7 +37,7 @@ func TestSerializeMetricInt(t *testing.T) {
fields := map[string]interface{}{
"usage_idle": int64(90),
}
m, err := telegraf.NewMetric("cpu", tags, fields, now)
m, err := metric.New("cpu", tags, fields, now)
assert.NoError(t, err)
s := JsonSerializer{}
@@ -55,7 +56,7 @@ func TestSerializeMetricString(t *testing.T) {
fields := map[string]interface{}{
"usage_idle": "foobar",
}
m, err := telegraf.NewMetric("cpu", tags, fields, now)
m, err := metric.New("cpu", tags, fields, now)
assert.NoError(t, err)
s := JsonSerializer{}
@@ -75,7 +76,7 @@ func TestSerializeMultiFields(t *testing.T) {
"usage_idle": int64(90),
"usage_total": 8559615,
}
m, err := telegraf.NewMetric("cpu", tags, fields, now)
m, err := metric.New("cpu", tags, fields, now)
assert.NoError(t, err)
s := JsonSerializer{}

6
plugins/serializers/registry.go
View File

@@ -18,8 +18,10 @@ type SerializerOutput interface {
// Serializer is an interface defining functions that a serializer plugin must
// satisfy.
type Serializer interface {
// Serialize takes a single telegraf metric and turns it into a string.
Serialize(metric telegraf.Metric) ([]string, error)
// Serialize takes a single telegraf metric and turns it into a byte buffer.
// separate metrics should be separated by a newline, and there should be
// a newline at the end of the buffer.
Serialize(metric telegraf.Metric) ([]byte, error)
}
// Config is a struct that covers the data types needed for all serializer types,