fastdto attempt.

Signed-off-by: bwplotka <[email protected]>

Author: bwplotka

prometheus/counter.go

@@ -19,6 +19,7 @@ import (
 	"sync/atomic"
 	"time"
 
+	"github.com/prometheus/client_golang/prometheus/internal/fastdto"
 	dto "github.com/prometheus/client_model/go"
 	"google.golang.org/protobuf/types/known/timestamppb"
 )
@@ -94,7 +95,7 @@ func NewCounter(opts CounterOpts) Counter {
 	if opts.now == nil {
 		opts.now = time.Now
 	}
-	result := &counter{desc: desc, labelPairs: desc.labelPairs, now: opts.now}
+	result := &counter{desc: desc, labelPairs: fastdto.ToDTOLabelPair(desc.labelPairs), now: opts.now}
 	result.init(result) // Init self-collection.
 	result.createdTs = timestamppb.New(opts.now())
 	return result

prometheus/desc.go

@@ -19,11 +19,8 @@ import (
 	"strings"
 
 	"github.com/cespare/xxhash/v2"
-	dto "github.com/prometheus/client_model/go"
+	"github.com/prometheus/client_golang/prometheus/internal/fastdto"
 	"github.com/prometheus/common/model"
-	"google.golang.org/protobuf/proto"
-
-	"github.com/prometheus/client_golang/prometheus/internal"
 )
 
 // Desc is the descriptor used by every Prometheus Metric. It is essentially
@@ -56,7 +53,7 @@ type Desc struct {
 	variableLabelOrder []int
 	// labelPairs contains the sorted DTO label pairs based on the constant labels
 	// and variable labels
-	labelPairs []*dto.LabelPair
+	labelPairs []fastdto.LabelPair
 	// id is a hash of the values of the ConstLabels and fqName. This
 	// must be unique among all registered descriptors and can therefore be
 	// used as an identifier of the descriptor.
@@ -164,24 +161,23 @@ func (v2) NewDesc(fqName, help string, variableLabels ConstrainableLabels, const
 	}
 	d.dimHash = xxh.Sum64()
 
-	d.labelPairs = make([]*dto.LabelPair, 0, len(constLabels)+len(d.variableLabels.names))
+	d.labelPairs = make([]fastdto.LabelPair, len(constLabels)+len(d.variableLabels.names))
+	i := 0
 	for n, v := range constLabels {
-		d.labelPairs = append(d.labelPairs, &dto.LabelPair{
-			Name:  proto.String(n),
-			Value: proto.String(v),
-		})
+		d.labelPairs[i].Name = n
+		d.labelPairs[i].Value = v
+		i++
 	}
 	for _, labelName := range d.variableLabels.names {
-		d.labelPairs = append(d.labelPairs, &dto.LabelPair{
-			Name: proto.String(labelName),
-		})
+		d.labelPairs[i].Name = labelName
+		i++
 	}
-	sort.Sort(internal.LabelPairSorter(d.labelPairs))
+	sort.Sort(fastdto.LabelPairSorter(d.labelPairs))
 
 	d.variableLabelOrder = make([]int, len(d.variableLabels.names))
 	for outputIndex, pair := range d.labelPairs {
 		// Constant labels have values variable labels do not.
-		if pair.Value != nil {
+		if pair.Value != "" {
 			continue
 		}
 		for sourceIndex, variableLabel := range d.variableLabels.names {
@@ -190,7 +186,6 @@ func (v2) NewDesc(fqName, help string, variableLabels ConstrainableLabels, const
 			}
 		}
 	}
-
 	return d
 }
 
@@ -207,7 +202,7 @@ func NewInvalidDesc(err error) *Desc {
 func (d *Desc) String() string {
 	lpStrings := make([]string, 0, len(d.labelPairs))
 	for _, lp := range d.labelPairs {
-		if lp.Value == nil {
+		if lp.Value == "" {
 			continue
 		}
 		lpStrings = append(

prometheus/desc_test.go

@@ -63,6 +63,18 @@ func TestNewInvalidDesc_String(t *testing.T) {
 	}
 }
 
+/*
+	 export bench=newDesc && go test ./prometheus \
+		-run '^$' -bench '^BenchmarkNewDesc/labels=10' \
+		-benchtime 5s -benchmem -cpu 2 -timeout 999m \
+		-memprofile=${bench}.mem.pprof \
+		| tee ${bench}.txt
+
+	 export bench=newDesc-v2 && go test ./prometheus \
+		-run '^$' -bench '^BenchmarkNewDesc' \
+		-benchtime 5s -benchmem -count=6 -cpu 2 -timeout 999m \
+		| tee ${bench}.txt
+*/
 func BenchmarkNewDesc(b *testing.B) {
 	for _, bm := range []struct {
 		labelCount int
@@ -82,6 +94,8 @@ func BenchmarkNewDesc(b *testing.B) {
 		},
 	} {
 		b.Run(fmt.Sprintf("labels=%v", bm.labelCount), func(b *testing.B) {
+			b.ReportAllocs()
+			b.ResetTimer()
 			for i := 0; i < b.N; i++ {
 				bm.descFunc()
 			}

prometheus/gauge.go

@@ -18,6 +18,7 @@ import (
 	"sync/atomic"
 	"time"
 
+	"github.com/prometheus/client_golang/prometheus/internal/fastdto"
 	dto "github.com/prometheus/client_model/go"
 )
 
@@ -82,7 +83,7 @@ func NewGauge(opts GaugeOpts) Gauge {
 		nil,
 		opts.ConstLabels,
 	)
-	result := &gauge{desc: desc, labelPairs: desc.labelPairs}
+	result := &gauge{desc: desc, labelPairs: fastdto.ToDTOLabelPair(desc.labelPairs)}
 	result.init(result) // Init self-collection.
 	return result
 }

prometheus/internal/fastdto/labels.go

@@ -0,0 +1,45 @@
+package fastdto
+
+import (
+	dto "github.com/prometheus/client_model/go"
+)
+
+type LabelPair struct {
+	Name  string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
+	Value string `protobuf:"bytes,2,opt,name=value" json:"value,omitempty"`
+}
+
+func (p LabelPair) GetName() string {
+	return p.Name
+}
+
+func (p LabelPair) GetValue() string {
+	return p.Value
+}
+
+// LabelPairSorter implements sort.Interface. It is used to sort a slice of
+// LabelPairs
+type LabelPairSorter []LabelPair
+
+func (s LabelPairSorter) Len() int {
+	return len(s)
+}
+
+func (s LabelPairSorter) Swap(i, j int) {
+	s[i], s[j] = s[j], s[i]
+}
+
+func (s LabelPairSorter) Less(i, j int) bool {
+	return s[i].Name < s[j].Name
+}
+
+func ToDTOLabelPair(in []LabelPair) []*dto.LabelPair {
+	ret := make([]*dto.LabelPair, len(in))
+	for i := range in {
+		ret[i] = &dto.LabelPair{
+			Name:  &(in[i].Name),
+			Value: &(in[i].Value),
+		}
+	}
+	return ret
+}

prometheus/internal/fastdto/labels_test.go

@@ -0,0 +1,58 @@
+package fastdto
+
+import (
+	"sort"
+	"testing"
+
+	"github.com/google/go-cmp/cmp"
+	"github.com/google/go-cmp/cmp/cmpopts"
+	dto "github.com/prometheus/client_model/go"
+	"google.golang.org/protobuf/proto"
+)
+
+func BenchmarkToDTOLabelPairs(b *testing.B) {
+	test := []LabelPair{
+		{"foo", "bar"},
+		{"foo2", "bar2"},
+		{"foo3", "bar3"},
+	}
+	b.ReportAllocs()
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		_ = ToDTOLabelPair(test)
+	}
+}
+
+func TestLabelPairSorter(t *testing.T) {
+	test := []LabelPair{
+		{"foo3", "bar3"},
+		{"foo", "bar"},
+		{"foo2", "bar2"},
+	}
+	sort.Sort(LabelPairSorter(test))
+
+	expected := []LabelPair{
+		{"foo", "bar"},
+		{"foo2", "bar2"},
+		{"foo3", "bar3"},
+	}
+	if diff := cmp.Diff(test, expected); diff != "" {
+		t.Fatal(diff)
+	}
+}
+
+func TestToDTOLabelPair(t *testing.T) {
+	test := []LabelPair{
+		{"foo", "bar"},
+		{"foo2", "bar2"},
+		{"foo3", "bar3"},
+	}
+	expected := []*dto.LabelPair{
+		{Name: proto.String("foo"), Value: proto.String("bar")},
+		{Name: proto.String("foo2"), Value: proto.String("bar2")},
+		{Name: proto.String("foo3"), Value: proto.String("bar3")},
+	}
+	if diff := cmp.Diff(ToDTOLabelPair(test), expected, cmpopts.IgnoreUnexported(dto.LabelPair{})); diff != "" {
+		t.Fatal(diff)
+	}
+}

prometheus/registry.go

@@ -971,7 +971,7 @@ func checkDescConsistency(
 	for i, lpFromDesc := range desc.labelPairs {
 		lpFromMetric := dtoMetric.Label[i]
 		if lpFromDesc.GetName() != lpFromMetric.GetName() ||
-			lpFromDesc.Value != nil && lpFromDesc.GetValue() != lpFromMetric.GetValue() {
+			lpFromDesc.Value != "" && lpFromDesc.GetValue() != lpFromMetric.GetValue() {
 			return fmt.Errorf(
 				"labels in collected metric %s %s are inconsistent with descriptor %s",
 				metricFamily.GetName(), dtoMetric, desc,

prometheus/value.go

@@ -19,6 +19,7 @@ import (
 	"time"
 	"unicode/utf8"
 
+	"github.com/prometheus/client_golang/prometheus/internal/fastdto"
 	dto "github.com/prometheus/client_model/go"
 	"google.golang.org/protobuf/proto"
 	"google.golang.org/protobuf/types/known/timestamppb"
@@ -216,28 +217,18 @@ func MakeLabelPairs(desc *Desc, labelValues []string) []*dto.LabelPair {
 		// Super fast path.
 		return nil
 	}
+
+	// Conversion copies all but strings.
+	ret := fastdto.ToDTOLabelPair(desc.labelPairs)
 	if len(desc.variableLabels.names) == 0 {
 		// Moderately fast path.
-		return desc.labelPairs
-	}
-	labelPairs := make([]*dto.LabelPair, 0, len(desc.labelPairs))
-	for _, lp := range desc.labelPairs {
-		var labelToAdd *dto.LabelPair
-		// Variable labels have no value and need to be inserted with a new dto.LabelPair containing the labelValue.
-		if lp.Value == nil {
-			labelToAdd = &dto.LabelPair{
-				Name: lp.Name,
-			}
-		} else {
-			labelToAdd = lp
-		}
-		labelPairs = append(labelPairs, labelToAdd)
+		return ret
 	}
+
 	for i, outputIndex := range desc.variableLabelOrder {
-		labelPairs[outputIndex].Value = proto.String(labelValues[i])
+		ret[outputIndex].Value = &labelValues[i] // Reusing string, assuming it's safe.
 	}
-
-	return labelPairs
+	return ret
 }
 
 // ExemplarMaxRunes is the max total number of runes allowed in exemplar labels.

prometheus/value_test.go

@@ -217,6 +217,18 @@ var new10LabelsDescFunc = func() *Desc {
 		Labels{"const-label-4": "value", "const-label-1": "value", "const-label-7": "value", "const-label-2": "value", "const-label-9": "value", "const-label-8": "value", "const-label-10": "value", "const-label-3": "value", "const-label-6": "value", "const-label-5": "value"})
 }
 
+/*
+	 export bench=makeLabelPairs-v2 && go test ./prometheus \
+		-run '^$' -bench '^BenchmarkMakeLabelPairs' \
+		-benchtime 5s -benchmem -count=6 -cpu 2 -timeout 999m \
+		| tee ${bench}.txt
+
+	export bench=makeLabelPairs-v2pp && go test ./prometheus \
+		-run '^$' -bench '^BenchmarkMakeLabelPairs' \
+		-benchtime 5s -benchmem -cpu 2 -timeout 999m \
+		-memprofile=${bench}.mem.pprof \
+		| tee ${bench}.txt
+*/
 func BenchmarkMakeLabelPairs(b *testing.B) {
 	for _, bm := range []struct {
 		desc                *Desc
@@ -236,6 +248,8 @@ func BenchmarkMakeLabelPairs(b *testing.B) {
 		},
 	} {
 		b.Run(fmt.Sprintf("labels=%v", len(bm.makeLabelPairValues)), func(b *testing.B) {
+			b.ReportAllocs()
+			b.ResetTimer()
 			for i := 0; i < b.N; i++ {
 				MakeLabelPairs(bm.desc, bm.makeLabelPairValues)
 			}

prometheus/wrap.go

@@ -190,8 +190,8 @@ func wrapDesc(desc *Desc, prefix string, labels Labels) *Desc {
 	constLabels := Labels{}
 	for _, lp := range desc.labelPairs {
 		// Variable labels have no values
-		if lp.Value != nil {
-			constLabels[*lp.Name] = *lp.Value
+		if lp.Value == "" {
+			constLabels[lp.Name] = lp.Value
 		}
 	}
 	for ln, lv := range labels {