rename DoubleGauge -> Gauge (#3599)

CHANGELOG.md

@@ -5,6 +5,7 @@
 ## 🛑 Breaking changes 🛑
 
 - Rename `pdata.DoubleSum` to `pdata.Sum` (#3583)
+- Rename `pdata.DoubleGauge` to `pdata.Gauge` (#3599)
 
 ## 🧰 Bug fixes 🧰
 

cmd/mdatagen/metricdata.go

@@ -22,7 +22,7 @@ var (
 	_ MetricData = &intGauge{}
 	_ MetricData = &intSum{}
 	_ MetricData = &intHistogram{}
-	_ MetricData = &doubleGauge{}
+	_ MetricData = &gauge{}
 	_ MetricData = &sum{}
 	_ MetricData = &histogram{}
 )
@@ -50,8 +50,8 @@ func (e *ymlMetricData) UnmarshalYAML(unmarshal func(interface{}) error) error {
 		md = &intSum{}
 	case "int histogram":
 		md = &intHistogram{}
-	case "double gauge":
-		md = &doubleGauge{}
+	case "gauge":
+		md = &gauge{}
 	case "sum":
 		md = &sum{}
 	case "histogram":
@@ -116,18 +116,18 @@ func (i intGauge) HasAggregated() bool {
 	return false
 }
 
-type doubleGauge struct {
+type gauge struct {
 }
 
-func (d doubleGauge) Type() string {
-	return "DoubleGauge"
+func (d gauge) Type() string {
+	return "Gauge"
 }
 
-func (d doubleGauge) HasMonotonic() bool {
+func (d gauge) HasMonotonic() bool {
 	return false
 }
 
-func (d doubleGauge) HasAggregated() bool {
+func (d gauge) HasAggregated() bool {
 	return false
 }
 

cmd/mdatagen/metricdata_test.go

@@ -30,7 +30,7 @@ func TestMetricData(t *testing.T) {
 		{&intGauge{}, "IntGauge", false, false},
 		{&intSum{}, "IntSum", true, true},
 		{&intHistogram{}, "IntHistogram", true, false},
-		{&doubleGauge{}, "DoubleGauge", false, false},
+		{&gauge{}, "Gauge", false, false},
 		{&sum{}, "Sum", true, true},
 		{&histogram{}, "Histogram", true, false},
 	} {

cmd/pdatagen/internal/metrics_structs.go

@@ -141,8 +141,8 @@ var intGauge = &messageValueStruct{
 }
 
 var doubleGauge = &messageValueStruct{
-	structName:     "DoubleGauge",
-	description:    "// DoubleGauge represents the type of a double scalar metric that always exports the \"current value\" for every data point.",
+	structName:     "Gauge",
+	description:    "// Gauge represents the type of a double scalar metric that always exports the \"current value\" for every data point.",
 	originFullName: "otlpmetrics.Gauge",
 	fields: []baseField{
 		&sliceField{

docs/metric-metadata.yaml

@@ -23,7 +23,7 @@ metrics:
     unit:
     # Required
     data:
-      # Required: one of int gauge, int sum, int histogram, double gauge, sum, or histogram.
+      # Required: one of int gauge, int sum, int histogram, gauge, sum, or histogram.
       type:
       # Required for int sum and sum.
       monotonic: # true | false

exporter/exporterhelper/resource_to_label.go

@@ -73,8 +73,8 @@ func addLabelsToMetric(metric *pdata.Metric, labelMap pdata.StringMap) {
 	switch metric.DataType() {
 	case pdata.MetricDataTypeIntGauge:
 		addLabelsToIntDataPoints(metric.IntGauge().DataPoints(), labelMap)
-	case pdata.MetricDataTypeDoubleGauge:
-		addLabelsToDoubleDataPoints(metric.DoubleGauge().DataPoints(), labelMap)
+	case pdata.MetricDataTypeGauge:
+		addLabelsToDoubleDataPoints(metric.Gauge().DataPoints(), labelMap)
 	case pdata.MetricDataTypeIntSum:
 		addLabelsToIntDataPoints(metric.IntSum().DataPoints(), labelMap)
 	case pdata.MetricDataTypeSum:

exporter/exporterhelper/resource_to_label_test.go

@@ -46,7 +46,7 @@ func TestConvertResourceToLabelsAllDataTypesEmptyDataPoint(t *testing.T) {
 
 	// Before converting resource to labels
 	assert.Equal(t, 1, md.ResourceMetrics().At(0).Resource().Attributes().Len())
-	assert.Equal(t, 0, md.ResourceMetrics().At(0).InstrumentationLibraryMetrics().At(0).Metrics().At(0).DoubleGauge().DataPoints().At(0).LabelsMap().Len())
+	assert.Equal(t, 0, md.ResourceMetrics().At(0).InstrumentationLibraryMetrics().At(0).Metrics().At(0).Gauge().DataPoints().At(0).LabelsMap().Len())
 	assert.Equal(t, 0, md.ResourceMetrics().At(0).InstrumentationLibraryMetrics().At(0).Metrics().At(1).IntGauge().DataPoints().At(0).LabelsMap().Len())
 	assert.Equal(t, 0, md.ResourceMetrics().At(0).InstrumentationLibraryMetrics().At(0).Metrics().At(2).Sum().DataPoints().At(0).LabelsMap().Len())
 	assert.Equal(t, 0, md.ResourceMetrics().At(0).InstrumentationLibraryMetrics().At(0).Metrics().At(3).IntSum().DataPoints().At(0).LabelsMap().Len())
@@ -57,15 +57,15 @@ func TestConvertResourceToLabelsAllDataTypesEmptyDataPoint(t *testing.T) {
 
 	// After converting resource to labels
 	assert.Equal(t, 1, cloneMd.ResourceMetrics().At(0).Resource().Attributes().Len())
-	assert.Equal(t, 1, cloneMd.ResourceMetrics().At(0).InstrumentationLibraryMetrics().At(0).Metrics().At(0).DoubleGauge().DataPoints().At(0).LabelsMap().Len())
+	assert.Equal(t, 1, cloneMd.ResourceMetrics().At(0).InstrumentationLibraryMetrics().At(0).Metrics().At(0).Gauge().DataPoints().At(0).LabelsMap().Len())
 	assert.Equal(t, 1, cloneMd.ResourceMetrics().At(0).InstrumentationLibraryMetrics().At(0).Metrics().At(1).IntGauge().DataPoints().At(0).LabelsMap().Len())
 	assert.Equal(t, 1, cloneMd.ResourceMetrics().At(0).InstrumentationLibraryMetrics().At(0).Metrics().At(2).Sum().DataPoints().At(0).LabelsMap().Len())
 	assert.Equal(t, 1, cloneMd.ResourceMetrics().At(0).InstrumentationLibraryMetrics().At(0).Metrics().At(3).IntSum().DataPoints().At(0).LabelsMap().Len())
 	assert.Equal(t, 1, cloneMd.ResourceMetrics().At(0).InstrumentationLibraryMetrics().At(0).Metrics().At(4).Histogram().DataPoints().At(0).LabelsMap().Len())
 	assert.Equal(t, 1, cloneMd.ResourceMetrics().At(0).InstrumentationLibraryMetrics().At(0).Metrics().At(5).IntHistogram().DataPoints().At(0).LabelsMap().Len())
 
 	assert.Equal(t, 1, md.ResourceMetrics().At(0).Resource().Attributes().Len())
-	assert.Equal(t, 0, md.ResourceMetrics().At(0).InstrumentationLibraryMetrics().At(0).Metrics().At(0).DoubleGauge().DataPoints().At(0).LabelsMap().Len())
+	assert.Equal(t, 0, md.ResourceMetrics().At(0).InstrumentationLibraryMetrics().At(0).Metrics().At(0).Gauge().DataPoints().At(0).LabelsMap().Len())
 	assert.Equal(t, 0, md.ResourceMetrics().At(0).InstrumentationLibraryMetrics().At(0).Metrics().At(1).IntGauge().DataPoints().At(0).LabelsMap().Len())
 	assert.Equal(t, 0, md.ResourceMetrics().At(0).InstrumentationLibraryMetrics().At(0).Metrics().At(2).Sum().DataPoints().At(0).LabelsMap().Len())
 	assert.Equal(t, 0, md.ResourceMetrics().At(0).InstrumentationLibraryMetrics().At(0).Metrics().At(3).IntSum().DataPoints().At(0).LabelsMap().Len())

exporter/prometheusexporter/accumulator.go

@@ -86,7 +86,7 @@ func (a *lastValueAccumulator) addMetric(metric pdata.Metric, il pdata.Instrumen
 		return a.accumulateIntGauge(metric, il, now)
 	case pdata.MetricDataTypeIntSum:
 		return a.accumulateIntSum(metric, il, now)
-	case pdata.MetricDataTypeDoubleGauge:
+	case pdata.MetricDataTypeGauge:
 		return a.accumulateDoubleGauge(metric, il, now)
 	case pdata.MetricDataTypeSum:
 		return a.accumulateSum(metric, il, now)
@@ -162,7 +162,7 @@ func (a *lastValueAccumulator) accumulateIntGauge(metric pdata.Metric, il pdata.
 }
 
 func (a *lastValueAccumulator) accumulateDoubleGauge(metric pdata.Metric, il pdata.InstrumentationLibrary, now time.Time) (n int) {
-	dps := metric.DoubleGauge().DataPoints()
+	dps := metric.Gauge().DataPoints()
 	for i := 0; i < dps.Len(); i++ {
 		ip := dps.At(i)
 
@@ -171,20 +171,20 @@ func (a *lastValueAccumulator) accumulateDoubleGauge(metric pdata.Metric, il pda
 		v, ok := a.registeredMetrics.Load(signature)
 		if !ok {
 			m := createMetric(metric)
-			ip.CopyTo(m.DoubleGauge().DataPoints().AppendEmpty())
+			ip.CopyTo(m.Gauge().DataPoints().AppendEmpty())
 			a.registeredMetrics.Store(signature, &accumulatedValue{value: m, instrumentationLibrary: il, updated: now})
 			n++
 			continue
 		}
 		mv := v.(*accumulatedValue)
 
-		if ip.Timestamp().AsTime().Before(mv.value.DoubleGauge().DataPoints().At(0).Timestamp().AsTime()) {
+		if ip.Timestamp().AsTime().Before(mv.value.Gauge().DataPoints().At(0).Timestamp().AsTime()) {
 			// only keep datapoint with latest timestamp
 			continue
 		}
 
 		m := createMetric(metric)
-		ip.CopyTo(m.DoubleGauge().DataPoints().AppendEmpty())
+		ip.CopyTo(m.Gauge().DataPoints().AppendEmpty())
 		a.registeredMetrics.Store(signature, &accumulatedValue{value: m, instrumentationLibrary: il, updated: now})
 		n++
 	}

exporter/prometheusexporter/accumulator_test.go

@@ -138,13 +138,13 @@ func TestAccumulateMetrics(t *testing.T) {
 			},
 		},
 		{
-			name: "DoubleGauge",
+			name: "Gauge",
 			metric: func(ts time.Time, v float64, metrics pdata.MetricSlice) {
 				metric := metrics.AppendEmpty()
 				metric.SetName("test_metric")
-				metric.SetDataType(pdata.MetricDataTypeDoubleGauge)
+				metric.SetDataType(pdata.MetricDataTypeGauge)
 				metric.SetDescription("test description")
-				dp := metric.DoubleGauge().DataPoints().AppendEmpty()
+				dp := metric.Gauge().DataPoints().AppendEmpty()
 				dp.SetValue(v)
 				dp.LabelsMap().Insert("label_1", "1")
 				dp.LabelsMap().Insert("label_2", "2")
@@ -339,10 +339,10 @@ func getMerticProperties(metric pdata.Metric) (
 		value = float64(metric.IntSum().DataPoints().At(0).Value())
 		temporality = metric.IntSum().AggregationTemporality()
 		isMonotonic = metric.IntSum().IsMonotonic()
-	case pdata.MetricDataTypeDoubleGauge:
-		labels = metric.DoubleGauge().DataPoints().At(0).LabelsMap()
-		ts = metric.DoubleGauge().DataPoints().At(0).Timestamp().AsTime()
-		value = metric.DoubleGauge().DataPoints().At(0).Value()
+	case pdata.MetricDataTypeGauge:
+		labels = metric.Gauge().DataPoints().At(0).LabelsMap()
+		ts = metric.Gauge().DataPoints().At(0).Timestamp().AsTime()
+		value = metric.Gauge().DataPoints().At(0).Value()
 		temporality = pdata.AggregationTemporalityUnspecified
 		isMonotonic = false
 	case pdata.MetricDataTypeSum:

exporter/prometheusexporter/collector.go

@@ -62,7 +62,7 @@ func (c *collector) convertMetric(metric pdata.Metric) (prometheus.Metric, error
 		return c.convertIntGauge(metric)
 	case pdata.MetricDataTypeIntSum:
 		return c.convertIntSum(metric)
-	case pdata.MetricDataTypeDoubleGauge:
+	case pdata.MetricDataTypeGauge:
 		return c.convertDoubleGauge(metric)
 	case pdata.MetricDataTypeSum:
 		return c.convertSum(metric)
@@ -118,7 +118,7 @@ func (c *collector) convertIntGauge(metric pdata.Metric) (prometheus.Metric, err
 }
 
 func (c *collector) convertDoubleGauge(metric pdata.Metric) (prometheus.Metric, error) {
-	ip := metric.DoubleGauge().DataPoints().At(0)
+	ip := metric.Gauge().DataPoints().At(0)
 
 	desc, labels := c.getMetricMetadata(metric, ip.LabelsMap())
 	m, err := prometheus.NewConstMetric(desc, prometheus.GaugeValue, ip.Value(), labels...)

exporter/prometheusexporter/collector_test.go

@@ -71,7 +71,7 @@ func TestConvertInvalidMetric(t *testing.T) {
 		pdata.MetricDataTypeIntHistogram,
 		pdata.MetricDataTypeSum,
 		pdata.MetricDataTypeIntSum,
-		pdata.MetricDataTypeDoubleGauge,
+		pdata.MetricDataTypeGauge,
 		pdata.MetricDataTypeIntGauge,
 	} {
 		metric := pdata.NewMetric()
@@ -81,8 +81,8 @@ func TestConvertInvalidMetric(t *testing.T) {
 			metric.IntGauge().DataPoints().AppendEmpty()
 		case pdata.MetricDataTypeIntSum:
 			metric.IntSum().DataPoints().AppendEmpty()
-		case pdata.MetricDataTypeDoubleGauge:
-			metric.DoubleGauge().DataPoints().AppendEmpty()
+		case pdata.MetricDataTypeGauge:
+			metric.Gauge().DataPoints().AppendEmpty()
 		case pdata.MetricDataTypeSum:
 			metric.Sum().DataPoints().AppendEmpty()
 		case pdata.MetricDataTypeIntHistogram:
@@ -187,15 +187,15 @@ func TestCollectMetrics(t *testing.T) {
 			},
 		},
 		{
-			name:       "DoubleGauge",
+			name:       "Gauge",
 			metricType: prometheus.GaugeValue,
 			value:      42.42,
 			metric: func(ts time.Time) (metric pdata.Metric) {
 				metric = pdata.NewMetric()
 				metric.SetName("test_metric")
-				metric.SetDataType(pdata.MetricDataTypeDoubleGauge)
+				metric.SetDataType(pdata.MetricDataTypeGauge)
 				metric.SetDescription("test description")
-				dp := metric.DoubleGauge().DataPoints().AppendEmpty()
+				dp := metric.Gauge().DataPoints().AppendEmpty()
 				dp.SetValue(42.42)
 				dp.LabelsMap().Insert("label_1", "1")
 				dp.LabelsMap().Insert("label_2", "2")

exporter/prometheusremotewriteexporter/exporter.go

@@ -130,8 +130,8 @@ func (prwe *PRWExporter) PushMetrics(ctx context.Context, md pdata.Metrics) erro
 
 					// handle individual metric based on type
 					switch metric.DataType() {
-					case pdata.MetricDataTypeDoubleGauge:
-						dataPoints := metric.DoubleGauge().DataPoints()
+					case pdata.MetricDataTypeGauge:
+						dataPoints := metric.Gauge().DataPoints()
 						if err := prwe.addDoubleDataPointSlice(dataPoints, tsMap, resource, metric); err != nil {
 							dropped++
 							errs = append(errs, err)

exporter/prometheusremotewriteexporter/helper.go

@@ -51,8 +51,8 @@ func (a ByLabelName) Swap(i, j int)      { a[i], a[j] = a[j], a[i] }
 // matching metric type and field
 func validateMetrics(metric pdata.Metric) bool {
 	switch metric.DataType() {
-	case pdata.MetricDataTypeDoubleGauge:
-		return metric.DoubleGauge().DataPoints().Len() != 0
+	case pdata.MetricDataTypeGauge:
+		return metric.Gauge().DataPoints().Len() != 0
 	case pdata.MetricDataTypeIntGauge:
 		return metric.IntGauge().DataPoints().Len() != 0
 	case pdata.MetricDataTypeSum:

exporter/prometheusremotewriteexporter/testutil_test.go

@@ -69,7 +69,7 @@ var (
 	ns1    = "test_ns"
 
 	twoPointsSameTs = map[string]*prompb.TimeSeries{
-		"DoubleGauge" + "-" + label11 + "-" + value11 + "-" + label12 + "-" + value12: getTimeSeries(getPromLabels(label11, value11, label12, value12),
+		"Gauge" + "-" + label11 + "-" + value11 + "-" + label12 + "-" + value12: getTimeSeries(getPromLabels(label11, value11, label12, value12),
 			getSample(float64(intVal1), msTime1),
 			getSample(float64(intVal2), msTime2)),
 	}
@@ -248,15 +248,15 @@ func getIntGaugeMetric(name string, labels pdata.StringMap, value int64, ts uint
 func getEmptyDoubleGaugeMetric(name string) pdata.Metric {
 	metric := pdata.NewMetric()
 	metric.SetName(name)
-	metric.SetDataType(pdata.MetricDataTypeDoubleGauge)
+	metric.SetDataType(pdata.MetricDataTypeGauge)
 	return metric
 }
 
 func getDoubleGaugeMetric(name string, labels pdata.StringMap, value float64, ts uint64) pdata.Metric {
 	metric := pdata.NewMetric()
 	metric.SetName(name)
-	metric.SetDataType(pdata.MetricDataTypeDoubleGauge)
-	dp := metric.DoubleGauge().DataPoints().AppendEmpty()
+	metric.SetDataType(pdata.MetricDataTypeGauge)
+	dp := metric.Gauge().DataPoints().AppendEmpty()
 	dp.SetValue(value)
 
 	labels.Range(func(k string, v string) bool {

internal/goldendataset/metrics_gen.go

@@ -120,9 +120,9 @@ func (g *metricGenerator) populateMetrics(cfg MetricsCfg, ilm pdata.Instrumentat
 		case pdata.MetricDataTypeIntGauge:
 			metric.SetDataType(pdata.MetricDataTypeIntGauge)
 			populateIntPoints(cfg, metric.IntGauge().DataPoints())
-		case pdata.MetricDataTypeDoubleGauge:
-			metric.SetDataType(pdata.MetricDataTypeDoubleGauge)
-			populateDoublePoints(cfg, metric.DoubleGauge().DataPoints())
+		case pdata.MetricDataTypeGauge:
+			metric.SetDataType(pdata.MetricDataTypeGauge)
+			populateDoublePoints(cfg, metric.Gauge().DataPoints())
 		case pdata.MetricDataTypeIntSum:
 			metric.SetDataType(pdata.MetricDataTypeIntSum)
 			sum := metric.IntSum()

internal/goldendataset/metrics_gen_test.go

@@ -115,10 +115,10 @@ func TestGenDoubleHistogram(t *testing.T) {
 
 func TestGenDoubleGauge(t *testing.T) {
 	cfg := DefaultCfg()
-	cfg.MetricDescriptorType = pdata.MetricDataTypeDoubleGauge
+	cfg.MetricDescriptorType = pdata.MetricDataTypeGauge
 	md := MetricsFromCfg(cfg)
 	metric := getMetric(md)
-	pts := metric.DoubleGauge().DataPoints()
+	pts := metric.Gauge().DataPoints()
 	require.Equal(t, 1, pts.Len())
 	pt := pts.At(0)
 	require.EqualValues(t, 1, pt.Value())

internal/goldendataset/pict_metrics_gen.go

@@ -73,7 +73,7 @@ func pictToCfg(inputs PICTMetricInputs) MetricsCfg {
 		cfg.MetricDescriptorType = pdata.MetricDataTypeIntSum
 		cfg.IsMonotonicSum = false
 	case MetricTypeDoubleGauge:
-		cfg.MetricDescriptorType = pdata.MetricDataTypeDoubleGauge
+		cfg.MetricDescriptorType = pdata.MetricDataTypeGauge
 	case MetricTypeMonotonicDoubleSum:
 		cfg.MetricDescriptorType = pdata.MetricDataTypeSum
 		cfg.IsMonotonicSum = true

internal/goldendataset/pict_metrics_gen_test.go

@@ -60,7 +60,7 @@ func TestPICTtoCfg(t *testing.T) {
 			cfg: MetricsCfg{
 				NumResourceAttrs:     1,
 				NumPtsPerMetric:      1,
-				MetricDescriptorType: pdata.MetricDataTypeDoubleGauge,
+				MetricDescriptorType: pdata.MetricDataTypeGauge,
 				NumPtLabels:          1,
 			},
 		},

internal/otlptext/databuffer.go

@@ -82,8 +82,8 @@ func (b *dataBuffer) logMetricDataPoints(m pdata.Metric) {
 		return
 	case pdata.MetricDataTypeIntGauge:
 		b.logIntDataPoints(m.IntGauge().DataPoints())
-	case pdata.MetricDataTypeDoubleGauge:
-		b.logDoubleDataPoints(m.DoubleGauge().DataPoints())
+	case pdata.MetricDataTypeGauge:
+		b.logDoubleDataPoints(m.Gauge().DataPoints())
 	case pdata.MetricDataTypeIntSum:
 		data := m.IntSum()
 		b.logEntry("     -> IsMonotonic: %t", data.IsMonotonic())

internal/processor/filterexpr/matcher.go

@@ -46,8 +46,8 @@ func (m *Matcher) MatchMetric(metric pdata.Metric) (bool, error) {
 	switch metric.DataType() {
 	case pdata.MetricDataTypeIntGauge:
 		return m.matchIntGauge(metricName, metric.IntGauge())
-	case pdata.MetricDataTypeDoubleGauge:
-		return m.matchDoubleGauge(metricName, metric.DoubleGauge())
+	case pdata.MetricDataTypeGauge:
+		return m.matchGauge(metricName, metric.Gauge())
 	case pdata.MetricDataTypeIntSum:
 		return m.matchIntSum(metricName, metric.IntSum())
 	case pdata.MetricDataTypeSum:
@@ -75,7 +75,7 @@ func (m *Matcher) matchIntGauge(metricName string, gauge pdata.IntGauge) (bool,
 	return false, nil
 }
 
-func (m *Matcher) matchDoubleGauge(metricName string, gauge pdata.DoubleGauge) (bool, error) {
+func (m *Matcher) matchGauge(metricName string, gauge pdata.Gauge) (bool, error) {
 	pts := gauge.DataPoints()
 	for i := 0; i < pts.Len(); i++ {
 		matched, err := m.matchEnv(metricName, pts.At(i).LabelsMap())