Use generic Sum, Gauge, and DataPoint value removing Value, Int64, and Float64 from metricdata

sdk/metric/metricdata/data.go

@@ -65,28 +65,28 @@ type Aggregation interface {
 }
 
 // Gauge represents a measurement of the current value of an instrument.
-type Gauge struct {
+type Gauge[N int64 | float64] struct {
 	// DataPoints reprents individual aggregated measurements with unique Attributes.
-	DataPoints []DataPoint
+	DataPoints []DataPoint[N]
 }
 
-func (Gauge) privateAggregation() {}
+func (Gauge[N]) privateAggregation() {}
 
 // Sum represents the sum of all measurements of values from an instrument.
-type Sum struct {
+type Sum[N int64 | float64] struct {
 	// DataPoints reprents individual aggregated measurements with unique Attributes.
-	DataPoints []DataPoint
+	DataPoints []DataPoint[N]
 	// Temporality describes if the aggregation is reported as the change from the
 	// last report time, or the cumulative changes since a fixed start time.
 	Temporality Temporality
 	// IsMonotonic represents if this aggregation only increases or decreases.
 	IsMonotonic bool
 }
 
-func (Sum) privateAggregation() {}
+func (Sum[N]) privateAggregation() {}
 
 // DataPoint is a single data point in a timeseries.
-type DataPoint struct {
+type DataPoint[N int64 | float64] struct {
 	// Attributes is the set of key value pairs that uniquely identify the
 	// timeseries.
 	Attributes attribute.Set
@@ -95,25 +95,9 @@ type DataPoint struct {
 	// Time is the time when the timeseries was recorded. (optional)
 	Time time.Time
 	// Value is the value of this data point.
-	Value Value
+	Value N
 }
 
-// Value is a int64 or float64. All Values created by the sdk will be either
-// Int64 or Float64.
-type Value interface {
-	privateValue()
-}
-
-// Int64 is a container for an int64 value.
-type Int64 int64
-
-func (Int64) privateValue() {}
-
-// Float64 is a container for a float64 value.
-type Float64 float64
-
-func (Float64) privateValue() {}
-
 // Histogram represents the histogram of all measurements of values from an instrument.
 type Histogram struct {
 	// DataPoints reprents individual aggregated measurements with unique Attributes.

sdk/metric/metricdata/metricdatatest/assertion.go

@@ -28,7 +28,17 @@ import (
 
 // Datatypes are the concrete data-types the metricdata package provides.
 type Datatypes interface {
-	metricdata.DataPoint | metricdata.Float64 | metricdata.Gauge | metricdata.Histogram | metricdata.HistogramDataPoint | metricdata.Int64 | metricdata.Metrics | metricdata.ResourceMetrics | metricdata.ScopeMetrics | metricdata.Sum
+	metricdata.DataPoint[float64] |
+		metricdata.DataPoint[int64] |
+		metricdata.Gauge[float64] |
+		metricdata.Gauge[int64] |
+		metricdata.Histogram |
+		metricdata.HistogramDataPoint |
+		metricdata.Metrics |
+		metricdata.ResourceMetrics |
+		metricdata.ScopeMetrics |
+		metricdata.Sum[float64] |
+		metricdata.Sum[int64]
 
 	// Interface types are not allowed in union types, therefore the
 	// Aggregation and Value type from metricdata are not included here.
@@ -44,26 +54,28 @@ func AssertEqual[T Datatypes](t *testing.T, expected, actual T) bool {
 
 	var r []string
 	switch e := interface{}(expected).(type) {
-	case metricdata.DataPoint:
-		r = equalDataPoints(e, aIface.(metricdata.DataPoint))
-	case metricdata.Float64:
-		r = equalFloat64(e, aIface.(metricdata.Float64))
-	case metricdata.Gauge:
-		r = equalGauges(e, aIface.(metricdata.Gauge))
+	case metricdata.DataPoint[int64]:
+		r = equalDataPoints(e, aIface.(metricdata.DataPoint[int64]))
+	case metricdata.DataPoint[float64]:
+		r = equalDataPoints(e, aIface.(metricdata.DataPoint[float64]))
+	case metricdata.Gauge[int64]:
+		r = equalGauges(e, aIface.(metricdata.Gauge[int64]))
+	case metricdata.Gauge[float64]:
+		r = equalGauges(e, aIface.(metricdata.Gauge[float64]))
 	case metricdata.Histogram:
 		r = equalHistograms(e, aIface.(metricdata.Histogram))
 	case metricdata.HistogramDataPoint:
 		r = equalHistogramDataPoints(e, aIface.(metricdata.HistogramDataPoint))
-	case metricdata.Int64:
-		r = equalInt64(e, aIface.(metricdata.Int64))
 	case metricdata.Metrics:
 		r = equalMetrics(e, aIface.(metricdata.Metrics))
 	case metricdata.ResourceMetrics:
 		r = equalResourceMetrics(e, aIface.(metricdata.ResourceMetrics))
 	case metricdata.ScopeMetrics:
 		r = equalScopeMetrics(e, aIface.(metricdata.ScopeMetrics))
-	case metricdata.Sum:
-		r = equalSums(e, aIface.(metricdata.Sum))
+	case metricdata.Sum[int64]:
+		r = equalSums(e, aIface.(metricdata.Sum[int64]))
+	case metricdata.Sum[float64]:
+		r = equalSums(e, aIface.(metricdata.Sum[float64]))
 	default:
 		// We control all types passed to this, panic to signal developers
 		// early they changed things in an incompatible way.
@@ -86,13 +98,3 @@ func AssertAggregationsEqual(t *testing.T, expected, actual metricdata.Aggregati
 	}
 	return true
 }
-
-// AssertValuesEqual asserts that two Values are equal.
-func AssertValuesEqual(t *testing.T, expected, actual metricdata.Value) bool {
-	t.Helper()
-	if r := equalValues(expected, actual); len(r) > 0 {
-		t.Error(r)
-		return false
-	}
-	return true
-}

sdk/metric/metricdata/metricdatatest/assertion_fail_test.go

@@ -37,27 +37,23 @@ func TestFailAssertEqual(t *testing.T) {
 	t.Run("ScopeMetrics", testFailDatatype(scopeMetricsA, scopeMetricsB))
 	t.Run("Metrics", testFailDatatype(metricsA, metricsB))
 	t.Run("Histogram", testFailDatatype(histogramA, histogramB))
-	t.Run("Sum", testFailDatatype(sumA, sumB))
-	t.Run("Gauge", testFailDatatype(gaugeA, gaugeB))
+	t.Run("SumInt64", testFailDatatype(sumInt64A, sumInt64B))
+	t.Run("SumFloat64", testFailDatatype(sumFloat64A, sumFloat64B))
+	t.Run("GaugeInt64", testFailDatatype(gaugeInt64A, gaugeInt64B))
+	t.Run("GaugeFloat64", testFailDatatype(gaugeFloat64A, gaugeFloat64B))
 	t.Run("HistogramDataPoint", testFailDatatype(histogramDataPointA, histogramDataPointB))
-	t.Run("DataPoint", testFailDatatype(dataPointsA, dataPointsB))
-	t.Run("Int64", testFailDatatype(int64A, int64B))
-	t.Run("Float64", testFailDatatype(float64A, float64B))
+	t.Run("DataPointInt64", testFailDatatype(dataPointInt64A, dataPointInt64B))
+	t.Run("DataPointFloat64", testFailDatatype(dataPointFloat64A, dataPointFloat64B))
+
 }
 
 func TestFailAssertAggregationsEqual(t *testing.T) {
-	AssertAggregationsEqual(t, sumA, nil)
-	AssertAggregationsEqual(t, sumA, gaugeA)
+	AssertAggregationsEqual(t, sumInt64A, nil)
+	AssertAggregationsEqual(t, sumFloat64A, gaugeFloat64A)
 	AssertAggregationsEqual(t, unknownAggregation{}, unknownAggregation{})
-	AssertAggregationsEqual(t, sumA, sumB)
-	AssertAggregationsEqual(t, gaugeA, gaugeB)
+	AssertAggregationsEqual(t, sumInt64A, sumInt64B)
+	AssertAggregationsEqual(t, sumFloat64A, sumFloat64B)
+	AssertAggregationsEqual(t, gaugeInt64A, gaugeInt64B)
+	AssertAggregationsEqual(t, gaugeFloat64A, gaugeFloat64B)
 	AssertAggregationsEqual(t, histogramA, histogramB)
 }
-
-func TestFailAssertValuesEqual(t *testing.T) {
-	AssertValuesEqual(t, int64A, nil)
-	AssertValuesEqual(t, int64A, float64A)
-	AssertValuesEqual(t, unknownValue{}, unknownValue{})
-	AssertValuesEqual(t, int64A, int64B)
-	AssertValuesEqual(t, float64A, float64B)
-}

sdk/metric/metricdata/metricdatatest/assertion_test.go

@@ -34,28 +34,34 @@ var (
 	attrA = attribute.NewSet(attribute.Bool("A", true))
 	attrB = attribute.NewSet(attribute.Bool("B", true))
 
-	float64A = metricdata.Float64(-1.0)
-	float64B = metricdata.Float64(2.0)
-
-	int64A = metricdata.Int64(-1)
-	int64B = metricdata.Int64(2)
-
 	startA = time.Now()
 	startB = startA.Add(time.Millisecond)
 	endA   = startA.Add(time.Second)
 	endB   = startB.Add(time.Second)
 
-	dataPointsA = metricdata.DataPoint{
+	dataPointInt64A = metricdata.DataPoint[int64]{
 		Attributes: attrA,
 		StartTime:  startA,
 		Time:       endA,
-		Value:      int64A,
+		Value:      -1,
+	}
+	dataPointFloat64A = metricdata.DataPoint[float64]{
+		Attributes: attrA,
+		StartTime:  startA,
+		Time:       endA,
+		Value:      -1.0,
+	}
+	dataPointInt64B = metricdata.DataPoint[int64]{
+		Attributes: attrB,
+		StartTime:  startB,
+		Time:       endB,
+		Value:      2,
 	}
-	dataPointsB = metricdata.DataPoint{
+	dataPointFloat64B = metricdata.DataPoint[float64]{
 		Attributes: attrB,
 		StartTime:  startB,
 		Time:       endB,
-		Value:      float64B,
+		Value:      2.0,
 	}
 
 	max, min            = 99.0, 3.
@@ -80,18 +86,38 @@ var (
 		Sum:          3,
 	}
 
-	gaugeA = metricdata.Gauge{DataPoints: []metricdata.DataPoint{dataPointsA}}
-	gaugeB = metricdata.Gauge{DataPoints: []metricdata.DataPoint{dataPointsB}}
+	gaugeInt64A = metricdata.Gauge[int64]{
+		DataPoints: []metricdata.DataPoint[int64]{dataPointInt64A},
+	}
+	gaugeFloat64A = metricdata.Gauge[float64]{
+		DataPoints: []metricdata.DataPoint[float64]{dataPointFloat64A},
+	}
+	gaugeInt64B = metricdata.Gauge[int64]{
+		DataPoints: []metricdata.DataPoint[int64]{dataPointInt64B},
+	}
+	gaugeFloat64B = metricdata.Gauge[float64]{
+		DataPoints: []metricdata.DataPoint[float64]{dataPointFloat64B},
+	}
 
-	sumA = metricdata.Sum{
+	sumInt64A = metricdata.Sum[int64]{
 		Temporality: metricdata.CumulativeTemporality,
 		IsMonotonic: true,
-		DataPoints:  []metricdata.DataPoint{dataPointsA},
+		DataPoints:  []metricdata.DataPoint[int64]{dataPointInt64A},
 	}
-	sumB = metricdata.Sum{
-		Temporality: metricdata.DeltaTemporality,
-		IsMonotonic: false,
-		DataPoints:  []metricdata.DataPoint{dataPointsB},
+	sumFloat64A = metricdata.Sum[float64]{
+		Temporality: metricdata.CumulativeTemporality,
+		IsMonotonic: true,
+		DataPoints:  []metricdata.DataPoint[float64]{dataPointFloat64A},
+	}
+	sumInt64B = metricdata.Sum[int64]{
+		Temporality: metricdata.CumulativeTemporality,
+		IsMonotonic: true,
+		DataPoints:  []metricdata.DataPoint[int64]{dataPointInt64B},
+	}
+	sumFloat64B = metricdata.Sum[float64]{
+		Temporality: metricdata.CumulativeTemporality,
+		IsMonotonic: true,
+		DataPoints:  []metricdata.DataPoint[float64]{dataPointFloat64B},
 	}
 
 	histogramA = metricdata.Histogram{
@@ -107,13 +133,13 @@ var (
 		Name:        "A",
 		Description: "A desc",
 		Unit:        unit.Dimensionless,
-		Data:        sumA,
+		Data:        sumInt64A,
 	}
 	metricsB = metricdata.Metrics{
 		Name:        "B",
 		Description: "B desc",
 		Unit:        unit.Bytes,
-		Data:        gaugeB,
+		Data:        gaugeFloat64B,
 	}
 
 	scopeMetricsA = metricdata.ScopeMetrics{
@@ -152,12 +178,13 @@ func TestAssertEqual(t *testing.T) {
 	t.Run("ScopeMetrics", testDatatype(scopeMetricsA, scopeMetricsB, equalScopeMetrics))
 	t.Run("Metrics", testDatatype(metricsA, metricsB, equalMetrics))
 	t.Run("Histogram", testDatatype(histogramA, histogramB, equalHistograms))
-	t.Run("Sum", testDatatype(sumA, sumB, equalSums))
-	t.Run("Gauge", testDatatype(gaugeA, gaugeB, equalGauges))
+	t.Run("SumInt64", testDatatype(sumInt64A, sumInt64B, equalSums[int64]))
+	t.Run("SumFloat64", testDatatype(sumFloat64A, sumFloat64B, equalSums[float64]))
+	t.Run("GaugeInt64", testDatatype(gaugeInt64A, gaugeInt64B, equalGauges[int64]))
+	t.Run("GaugeFloat64", testDatatype(gaugeFloat64A, gaugeFloat64B, equalGauges[float64]))
 	t.Run("HistogramDataPoint", testDatatype(histogramDataPointA, histogramDataPointB, equalHistogramDataPoints))
-	t.Run("DataPoint", testDatatype(dataPointsA, dataPointsB, equalDataPoints))
-	t.Run("Int64", testDatatype(int64A, int64B, equalInt64))
-	t.Run("Float64", testDatatype(float64A, float64B, equalFloat64))
+	t.Run("DataPointInt64", testDatatype(dataPointInt64A, dataPointInt64B, equalDataPoints[int64]))
+	t.Run("DataPointFloat64", testDatatype(dataPointFloat64A, dataPointFloat64B, equalDataPoints[float64]))
 }
 
 type unknownAggregation struct {
@@ -166,50 +193,33 @@ type unknownAggregation struct {
 
 func TestAssertAggregationsEqual(t *testing.T) {
 	AssertAggregationsEqual(t, nil, nil)
-	AssertAggregationsEqual(t, sumA, sumA)
-	AssertAggregationsEqual(t, gaugeA, gaugeA)
+	AssertAggregationsEqual(t, sumInt64A, sumInt64A)
+	AssertAggregationsEqual(t, sumFloat64A, sumFloat64A)
+	AssertAggregationsEqual(t, gaugeInt64A, gaugeInt64A)
+	AssertAggregationsEqual(t, gaugeFloat64A, gaugeFloat64A)
 	AssertAggregationsEqual(t, histogramA, histogramA)
 
-	r := equalAggregations(sumA, nil)
+	r := equalAggregations(sumInt64A, nil)
 	assert.Len(t, r, 1, "should return nil comparison mismatch only")
 
-	r = equalAggregations(sumA, gaugeA)
+	r = equalAggregations(sumInt64A, gaugeInt64A)
 	assert.Len(t, r, 1, "should return with type mismatch only")
 
 	r = equalAggregations(unknownAggregation{}, unknownAggregation{})
 	assert.Len(t, r, 1, "should return with unknown aggregation only")
 
-	r = equalAggregations(sumA, sumB)
-	assert.Greaterf(t, len(r), 0, "%v == %v", sumA, sumB)
-
-	r = equalAggregations(gaugeA, gaugeB)
-	assert.Greaterf(t, len(r), 0, "%v == %v", gaugeA, gaugeB)
-
-	r = equalAggregations(histogramA, histogramB)
-	assert.Greaterf(t, len(r), 0, "%v == %v", histogramA, histogramB)
-}
-
-type unknownValue struct {
-	metricdata.Value
-}
+	r = equalAggregations(sumInt64A, sumInt64B)
+	assert.Greaterf(t, len(r), 0, "%v == %v", sumInt64A, sumInt64B)
 
-func TestAssertValuesEqual(t *testing.T) {
-	AssertValuesEqual(t, nil, nil)
-	AssertValuesEqual(t, int64A, int64A)
-	AssertValuesEqual(t, float64A, float64A)
+	r = equalAggregations(sumFloat64A, sumFloat64B)
+	assert.Greaterf(t, len(r), 0, "%v == %v", sumFloat64A, sumFloat64B)
 
-	r := equalValues(int64A, nil)
-	assert.Len(t, r, 1, "should return nil comparison mismatch only")
+	r = equalAggregations(gaugeInt64A, gaugeInt64B)
+	assert.Greaterf(t, len(r), 0, "%v == %v", gaugeInt64A, gaugeInt64B)
 
-	r = equalValues(int64A, float64A)
-	assert.Len(t, r, 1, "should return with type mismatch only")
+	r = equalAggregations(gaugeFloat64A, gaugeFloat64B)
+	assert.Greaterf(t, len(r), 0, "%v == %v", gaugeFloat64A, gaugeFloat64B)
 
-	r = equalValues(unknownValue{}, unknownValue{})
-	assert.Len(t, r, 1, "should return with unknown value only")
-
-	r = equalValues(int64A, int64B)
-	assert.Greaterf(t, len(r), 0, "%v == %v", int64A, int64B)
-
-	r = equalValues(float64A, float64B)
-	assert.Greaterf(t, len(r), 0, "%v == %v", float64A, float64B)
+	r = equalAggregations(histogramA, histogramB)
+	assert.Greaterf(t, len(r), 0, "%v == %v", histogramA, histogramB)
 }