chore: Add metric and batch benchmark to serializers (#14277)

plugins/serializers/carbon2/carbon2_test.go

@@ -9,6 +9,7 @@ import (
 
 	"github.com/influxdata/telegraf"
 	"github.com/influxdata/telegraf/metric"
+	"github.com/influxdata/telegraf/plugins/serializers"
 )
 
 func TestSerializeMetricFloat(t *testing.T) {
@@ -416,3 +417,26 @@ func TestSerializeMetricIsProperlySanitized(t *testing.T) {
 		})
 	}
 }
+
+func BenchmarkSerialize(b *testing.B) {
+	s := &Serializer{}
+	require.NoError(b, s.Init())
+	metrics := serializers.BenchmarkMetrics(b)
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		_, err := s.Serialize(metrics[i%len(metrics)])
+		require.NoError(b, err)
+	}
+}
+
+func BenchmarkSerializeBatch(b *testing.B) {
+	s := &Serializer{}
+	require.NoError(b, s.Init())
+	m := serializers.BenchmarkMetrics(b)
+	metrics := m[:]
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		_, err := s.SerializeBatch(metrics)
+		require.NoError(b, err)
+	}
+}

plugins/serializers/cloudevents/cloudevents_test.go

@@ -10,7 +10,6 @@ import (
 	"path/filepath"
 	"strings"
 	"testing"
-	"time"
 
 	cloudevents "github.com/cloudevents/sdk-go/v2"
 	"github.com/gofrs/uuid/v5"
@@ -19,10 +18,10 @@ import (
 
 	"github.com/influxdata/telegraf"
 	"github.com/influxdata/telegraf/config"
-	"github.com/influxdata/telegraf/metric"
 	"github.com/influxdata/telegraf/models"
 	"github.com/influxdata/telegraf/plugins/outputs"
 	"github.com/influxdata/telegraf/plugins/parsers/influx"
+	"github.com/influxdata/telegraf/plugins/serializers"
 	"github.com/influxdata/telegraf/testutil"
 )
 
@@ -235,28 +234,25 @@ func (*dummygen) NewV7() (uuid.UUID, error) {
 	return uuid.UUID([16]byte{}), errors.New("wrong type")
 }
 
-/* Benchmarks */
+func BenchmarkSerialize(b *testing.B) {
-func BenchmarkSerializer(b *testing.B) {
+	s := &Serializer{}
-	m := metric.New(
+	require.NoError(b, s.Init())
-		"test",
+	metrics := serializers.BenchmarkMetrics(b)
-		map[string]string{
+	b.ResetTimer()
-			"source": "somehost.company.com",
+	for i := 0; i < b.N; i++ {
-			"host":   "localhost",
+		_, err := s.Serialize(metrics[i%len(metrics)])
-			"status": "healthy",
+		require.NoError(b, err)
-		},
+	}
-		map[string]interface{}{
+}
-			"temperature":     23.5,
+
-			"operating_hours": 4242,
+func BenchmarkSerializeBatch(b *testing.B) {
-			"connections":     123,
+	s := &Serializer{}
-			"standby":         true,
+	require.NoError(b, s.Init())
-			"SN":              "DC5423DE4CE/2",
+	m := serializers.BenchmarkMetrics(b)
-		},
+	metrics := m[:]
-		time.Now(),
+	b.ResetTimer()
-	)
+	for i := 0; i < b.N; i++ {
-
+		_, err := s.SerializeBatch(metrics)
-	serializer := &Serializer{}
-	for n := 0; n < b.N; n++ {
-		_, err := serializer.Serialize(m)
 		require.NoError(b, err)
 	}
 }

plugins/serializers/csv/csv_test.go

@@ -11,6 +11,7 @@ import (
 	"github.com/stretchr/testify/require"
 
 	"github.com/influxdata/telegraf/plugins/parsers/influx"
+	"github.com/influxdata/telegraf/plugins/serializers"
 	"github.com/influxdata/telegraf/testutil"
 )
 
@@ -201,3 +202,26 @@ func loadTestConfiguration(filename string) (*Config, []string, error) {
 func loadCSV(filename string) ([]byte, error) {
 	return os.ReadFile(filename)
 }
+
+func BenchmarkSerialize(b *testing.B) {
+	s := &Serializer{}
+	require.NoError(b, s.Init())
+	metrics := serializers.BenchmarkMetrics(b)
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		_, err := s.Serialize(metrics[i%len(metrics)])
+		require.NoError(b, err)
+	}
+}
+
+func BenchmarkSerializeBatch(b *testing.B) {
+	s := &Serializer{}
+	require.NoError(b, s.Init())
+	m := serializers.BenchmarkMetrics(b)
+	metrics := m[:]
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		_, err := s.SerializeBatch(metrics)
+		require.NoError(b, err)
+	}
+}

plugins/serializers/graphite/graphite_test.go

@@ -11,6 +11,7 @@ import (
 
 	"github.com/influxdata/telegraf"
 	"github.com/influxdata/telegraf/metric"
+	"github.com/influxdata/telegraf/plugins/serializers"
 )
 
 var defaultTags = map[string]string{
@@ -1216,3 +1217,26 @@ func TestSerializeBatchWithTagsSupport(t *testing.T) {
 		})
 	}
 }
+
+func BenchmarkSerialize(b *testing.B) {
+	s := &GraphiteSerializer{}
+	require.NoError(b, s.Init())
+	metrics := serializers.BenchmarkMetrics(b)
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		_, err := s.Serialize(metrics[i%len(metrics)])
+		require.NoError(b, err)
+	}
+}
+
+func BenchmarkSerializeBatch(b *testing.B) {
+	s := &GraphiteSerializer{}
+	require.NoError(b, s.Init())
+	m := serializers.BenchmarkMetrics(b)
+	metrics := m[:]
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		_, err := s.SerializeBatch(metrics)
+		require.NoError(b, err)
+	}
+}

plugins/serializers/influx/influx_test.go

@@ -9,6 +9,7 @@ import (
 
 	"github.com/influxdata/telegraf"
 	"github.com/influxdata/telegraf/metric"
+	"github.com/influxdata/telegraf/plugins/serializers"
 )
 
 var tests = []struct {
@@ -531,3 +532,26 @@ func TestSerialize_SerializeBatch(t *testing.T) {
 	require.NoError(t, err)
 	require.Equal(t, []byte("cpu value=42 0\ncpu value=42 0\n"), output)
 }
+
+func BenchmarkSerialize(b *testing.B) {
+	s := &Serializer{}
+	require.NoError(b, s.Init())
+	metrics := serializers.BenchmarkMetrics(b)
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		_, err := s.Serialize(metrics[i%len(metrics)])
+		require.NoError(b, err)
+	}
+}
+
+func BenchmarkSerializeBatch(b *testing.B) {
+	s := &Serializer{}
+	require.NoError(b, s.Init())
+	m := serializers.BenchmarkMetrics(b)
+	metrics := m[:]
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		_, err := s.SerializeBatch(metrics)
+		require.NoError(b, err)
+	}
+}

plugins/serializers/json/json_test.go

@@ -17,6 +17,7 @@ import (
 	"github.com/influxdata/telegraf/config"
 	"github.com/influxdata/telegraf/metric"
 	"github.com/influxdata/telegraf/plugins/parsers/influx"
+	"github.com/influxdata/telegraf/plugins/serializers"
 	"github.com/influxdata/telegraf/testutil"
 )
 
@@ -488,3 +489,26 @@ func loadJSON(filename string) (interface{}, error) {
 	err = json.Unmarshal(buf, &data)
 	return data, err
 }
+
+func BenchmarkSerialize(b *testing.B) {
+	s := &Serializer{}
+	require.NoError(b, s.Init())
+	metrics := serializers.BenchmarkMetrics(b)
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		_, err := s.Serialize(metrics[i%len(metrics)])
+		require.NoError(b, err)
+	}
+}
+
+func BenchmarkSerializeBatch(b *testing.B) {
+	s := &Serializer{}
+	require.NoError(b, s.Init())
+	m := serializers.BenchmarkMetrics(b)
+	metrics := m[:]
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		_, err := s.SerializeBatch(metrics)
+		require.NoError(b, err)
+	}
+}

plugins/serializers/msgpack/msgpack_test.go

@@ -7,6 +7,7 @@ import (
 
 	"github.com/influxdata/telegraf"
 	"github.com/influxdata/telegraf/metric"
+	"github.com/influxdata/telegraf/plugins/serializers"
 	"github.com/influxdata/telegraf/testutil"
 )
 
@@ -130,3 +131,24 @@ func TestSerializeBatch(t *testing.T) {
 		testutil.RequireMetricEqual(t, m, toTelegrafMetric(*decodeM))
 	}
 }
+
+func BenchmarkSerialize(b *testing.B) {
+	s := &Serializer{}
+	metrics := serializers.BenchmarkMetrics(b)
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		_, err := s.Serialize(metrics[i%len(metrics)])
+		require.NoError(b, err)
+	}
+}
+
+func BenchmarkSerializeBatch(b *testing.B) {
+	s := &Serializer{}
+	m := serializers.BenchmarkMetrics(b)
+	metrics := m[:]
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		_, err := s.SerializeBatch(metrics)
+		require.NoError(b, err)
+	}
+}

plugins/serializers/nowmetric/nowmetric_test.go

@@ -10,6 +10,7 @@ import (
 
 	"github.com/influxdata/telegraf"
 	"github.com/influxdata/telegraf/metric"
+	"github.com/influxdata/telegraf/plugins/serializers"
 )
 
 func TestSerializeMetricFloat(t *testing.T) {
@@ -248,3 +249,26 @@ func TestSerializeInvalidFormat(t *testing.T) {
 	s := &Serializer{Format: "foo"}
 	require.Error(t, s.Init())
 }
+
+func BenchmarkSerialize(b *testing.B) {
+	s := &Serializer{}
+	require.NoError(b, s.Init())
+	metrics := serializers.BenchmarkMetrics(b)
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		_, err := s.Serialize(metrics[i%len(metrics)])
+		require.NoError(b, err)
+	}
+}
+
+func BenchmarkSerializeBatch(b *testing.B) {
+	s := &Serializer{}
+	require.NoError(b, s.Init())
+	m := serializers.BenchmarkMetrics(b)
+	metrics := m[:]
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		_, err := s.SerializeBatch(metrics)
+		require.NoError(b, err)
+	}
+}

plugins/serializers/prometheus/prometheus_test.go

@@ -8,6 +8,7 @@ import (
 	"github.com/stretchr/testify/require"
 
 	"github.com/influxdata/telegraf"
+	"github.com/influxdata/telegraf/plugins/serializers"
 	"github.com/influxdata/telegraf/testutil"
 )
 
@@ -760,3 +761,26 @@ rpc_duration_seconds_count 2693
 		})
 	}
 }
+
+func BenchmarkSerialize(b *testing.B) {
+	s := &Serializer{}
+	require.NoError(b, s.Init())
+	metrics := serializers.BenchmarkMetrics(b)
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		_, err := s.Serialize(metrics[i%len(metrics)])
+		require.NoError(b, err)
+	}
+}
+
+func BenchmarkSerializeBatch(b *testing.B) {
+	s := &Serializer{}
+	require.NoError(b, s.Init())
+	m := serializers.BenchmarkMetrics(b)
+	metrics := m[:]
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		_, err := s.SerializeBatch(metrics)
+		require.NoError(b, err)
+	}
+}

plugins/serializers/prometheusremotewrite/prometheusremotewrite_test.go

@@ -13,6 +13,7 @@ import (
 	"github.com/stretchr/testify/require"
 
 	"github.com/influxdata/telegraf"
+	"github.com/influxdata/telegraf/plugins/serializers"
 	"github.com/influxdata/telegraf/testutil"
 )
 
@@ -734,3 +735,24 @@ func protoToSamples(req *prompb.WriteRequest) model.Samples {
 	}
 	return samples
 }
+
+func BenchmarkSerialize(b *testing.B) {
+	s := &Serializer{}
+	metrics := serializers.BenchmarkMetrics(b)
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		_, err := s.Serialize(metrics[i%len(metrics)])
+		require.NoError(b, err)
+	}
+}
+
+func BenchmarkSerializeBatch(b *testing.B) {
+	s := &Serializer{}
+	m := serializers.BenchmarkMetrics(b)
+	metrics := m[:]
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		_, err := s.SerializeBatch(metrics)
+		require.NoError(b, err)
+	}
+}

plugins/serializers/splunkmetric/splunkmetric_test.go

@@ -8,6 +8,7 @@ import (
 
 	"github.com/influxdata/telegraf"
 	"github.com/influxdata/telegraf/metric"
+	"github.com/influxdata/telegraf/plugins/serializers"
 )
 
 func TestSerializeMetricFloat(t *testing.T) {
@@ -266,3 +267,24 @@ func TestSerializeOmitEvent(t *testing.T) {
 	expS := `{"time":0,"fields":{"metric_name:cpu.system":8,"metric_name:cpu.usage":42}}`
 	require.Equal(t, expS, string(buf))
 }
+
+func BenchmarkSerialize(b *testing.B) {
+	s := &Serializer{}
+	metrics := serializers.BenchmarkMetrics(b)
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		_, err := s.Serialize(metrics[i%len(metrics)])
+		require.NoError(b, err)
+	}
+}
+
+func BenchmarkSerializeBatch(b *testing.B) {
+	s := &Serializer{}
+	m := serializers.BenchmarkMetrics(b)
+	metrics := m[:]
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		_, err := s.SerializeBatch(metrics)
+		require.NoError(b, err)
+	}
+}

plugins/serializers/template/template_test.go

@@ -8,6 +8,7 @@ import (
 
 	"github.com/influxdata/telegraf"
 	"github.com/influxdata/telegraf/metric"
+	"github.com/influxdata/telegraf/plugins/serializers"
 )
 
 func TestSerializer(t *testing.T) {
@@ -179,3 +180,26 @@ func TestSerializeBatch(t *testing.T) {
 	require.NoError(t, err)
 	require.Equal(t, "0: cpu 42\n", string(singleBuf))
 }
+
+func BenchmarkSerialize(b *testing.B) {
+	s := &Serializer{}
+	require.NoError(b, s.Init())
+	metrics := serializers.BenchmarkMetrics(b)
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		_, err := s.Serialize(metrics[i%len(metrics)])
+		require.NoError(b, err)
+	}
+}
+
+func BenchmarkSerializeBatch(b *testing.B) {
+	s := &Serializer{}
+	require.NoError(b, s.Init())
+	m := serializers.BenchmarkMetrics(b)
+	metrics := m[:]
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		_, err := s.SerializeBatch(metrics)
+		require.NoError(b, err)
+	}
+}

plugins/serializers/test_benchmark.go

@@ -0,0 +1,31 @@
+package serializers
+
+import (
+	"testing"
+	"time"
+
+	"github.com/influxdata/telegraf"
+	"github.com/influxdata/telegraf/metric"
+)
+
+func BenchmarkMetrics(b *testing.B) [4]telegraf.Metric {
+	b.Helper()
+	now := time.Now()
+	tags := map[string]string{
+		"cpu":  "cpu0",
+		"host": "realHost",
+	}
+	newMetric := func(v interface{}) telegraf.Metric {
+		fields := map[string]interface{}{
+			"usage_idle": v,
+		}
+		m := metric.New("cpu", tags, fields, now)
+		return m
+	}
+	return [4]telegraf.Metric{
+		newMetric(91.5),
+		newMetric(91),
+		newMetric(true),
+		newMetric(false),
+	}
+}

plugins/serializers/wavefront/wavefront_test.go

@@ -9,8 +9,8 @@ import (
 
 	"github.com/stretchr/testify/require"
 
-	"github.com/influxdata/telegraf"
 	"github.com/influxdata/telegraf/metric"
+	"github.com/influxdata/telegraf/plugins/serializers"
 )
 
 func TestBuildTags(t *testing.T) {
@@ -285,31 +285,9 @@ func TestSerializeMetricPrefix(t *testing.T) {
 	require.Equal(t, expS, mS)
 }
 
-func benchmarkMetrics(b *testing.B) [4]telegraf.Metric {
-	b.Helper()
-	now := time.Now()
-	tags := map[string]string{
-		"cpu":  "cpu0",
-		"host": "realHost",
-	}
-	newMetric := func(v interface{}) telegraf.Metric {
-		fields := map[string]interface{}{
-			"usage_idle": v,
-		}
-		m := metric.New("cpu", tags, fields, now)
-		return m
-	}
-	return [4]telegraf.Metric{
-		newMetric(91.5),
-		newMetric(91),
-		newMetric(true),
-		newMetric(false),
-	}
-}
-
 func BenchmarkSerialize(b *testing.B) {
 	s := &Serializer{}
-	metrics := benchmarkMetrics(b)
+	metrics := serializers.BenchmarkMetrics(b)
 	b.ResetTimer()
 	for i := 0; i < b.N; i++ {
 		_, err := s.Serialize(metrics[i%len(metrics)])
@@ -319,7 +297,7 @@ func BenchmarkSerialize(b *testing.B) {
 
 func BenchmarkSerializeBatch(b *testing.B) {
 	s := &Serializer{}
-	m := benchmarkMetrics(b)
+	m := serializers.BenchmarkMetrics(b)
 	metrics := m[:]
 	b.ResetTimer()
 	for i := 0; i < b.N; i++ {