Skip to content

Refactor exponential histogram tests to use existing fixtures #4747

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
MrAlias merged 4 commits into from
Dec 9, 2023
+146 −128
Merged

Refactor exponential histogram tests to use existing fixtures #4747

Changes from all commits
Commits
Show all changes
4 commits
Select commit Hold shift + click to select a range
245ec4b
Refactor expo hist test to use existing fixtures
MrAlias Dec 6, 2023
4f0ea03
Add alt input for cumulative test
MrAlias Dec 7, 2023
6327887
Merge branch 'main' into expo-hist-test-unify
MrAlias Dec 7, 2023
388ddac
Merge branch 'main' into expo-hist-test-unify
MrAlias Dec 9, 2023
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
274 changes: 146 additions & 128 deletions sdk/metric/internal/aggregate/exponential_histogram_test.go
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -23,10 +23,8 @@ import (
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"

"go.opentelemetry.io/otel/attribute"
"go.opentelemetry.io/otel/internal/global"
"go.opentelemetry.io/otel/sdk/metric/metricdata"
"go.opentelemetry.io/otel/sdk/metric/metricdata/metricdatatest"
)

type noErrorHandler struct{ t *testing.T }
Expand Down Expand Up @@ -739,161 +737,181 @@ func TestSubNormal(t *testing.T) {
}

func TestExponentialHistogramAggregation(t *testing.T) {
t.Run("Int64", testExponentialHistogramAggregation[int64])
t.Run("Float64", testExponentialHistogramAggregation[float64])
}
t.Cleanup(mockTime(now))

func testExponentialHistogramAggregation[N int64 | float64](t *testing.T) {
const (
maxSize = 4
maxScale = 20
noMinMax = false
noSum = false
)
t.Run("Int64/Delta", testDeltaExpoHist[int64]())
t.Run("Float64/Delta", testDeltaExpoHist[float64]())
t.Run("Int64/Cumulative", testCumulativeExpoHist[int64]())
t.Run("Float64/Cumulative", testCumulativeExpoHist[float64]())
}

tests := []struct {
name string
build func() (Measure[N], ComputeAggregation)
input [][]N
want metricdata.ExponentialHistogram[N]
wantCount int
}{
func testDeltaExpoHist[N int64 | float64]() func(t *testing.T) {
in, out := Builder[N]{
Temporality: metricdata.DeltaTemporality,
Filter: attrFltr,
}.ExponentialBucketHistogram(4, 20, false, false)
ctx := context.Background()
return test[N](in, out, []teststep[N]{
{
input: []arg[N]{},
expect: output{
n: 0,
agg: metricdata.ExponentialHistogram[N]{
Temporality: metricdata.DeltaTemporality,
DataPoints: []metricdata.ExponentialHistogramDataPoint[N]{},
},
},
},
{
name: "Delta Single",
build: func() (Measure[N], ComputeAggregation) {
return Builder[N]{
input: []arg[N]{
{ctx, 4, alice},
{ctx, 4, alice},
{ctx, 4, alice},
{ctx, 2, alice},
{ctx, 16, alice},
{ctx, 1, alice},
},
expect: output{
n: 1,
agg: metricdata.ExponentialHistogram[N]{
Temporality: metricdata.DeltaTemporality,
}.ExponentialBucketHistogram(maxSize, maxScale, noMinMax, noSum)
},
input: [][]N{
{4, 4, 4, 2, 16, 1},
},
want: metricdata.ExponentialHistogram[N]{
Temporality: metricdata.DeltaTemporality,
DataPoints: []metricdata.ExponentialHistogramDataPoint[N]{
{
Count: 6,
Min: metricdata.NewExtrema[N](1),
Max: metricdata.NewExtrema[N](16),
Sum: 31,
Scale: -1,
PositiveBucket: metricdata.ExponentialBucket{
Offset: -1,
Counts: []uint64{1, 4, 1},
DataPoints: []metricdata.ExponentialHistogramDataPoint[N]{
{
Attributes: fltrAlice,
StartTime: staticTime,
Time: staticTime,
Count: 6,
Min: metricdata.NewExtrema[N](1),
Max: metricdata.NewExtrema[N](16),
Sum: 31,
Scale: -1,
PositiveBucket: metricdata.ExponentialBucket{
Offset: -1,
Counts: []uint64{1, 4, 1},
},
},
},
},
},
wantCount: 1,
},
{
name: "Cumulative Single",
build: func() (Measure[N], ComputeAggregation) {
return Builder[N]{
// Delta sums are expected to reset.
input: []arg[N]{},
expect: output{
n: 0,
agg: metricdata.ExponentialHistogram[N]{
Temporality: metricdata.DeltaTemporality,
DataPoints: []metricdata.ExponentialHistogramDataPoint[N]{},
},
},
},
})
}

func testCumulativeExpoHist[N int64 | float64]() func(t *testing.T) {
in, out := Builder[N]{
Temporality: metricdata.CumulativeTemporality,
Filter: attrFltr,
}.ExponentialBucketHistogram(4, 20, false, false)
ctx := context.Background()
return test[N](in, out, []teststep[N]{
{
input: []arg[N]{},
expect: output{
n: 0,
agg: metricdata.ExponentialHistogram[N]{
Temporality: metricdata.CumulativeTemporality,
}.ExponentialBucketHistogram(maxSize, maxScale, noMinMax, noSum)
},
input: [][]N{
{4, 4, 4, 2, 16, 1},
},
want: metricdata.ExponentialHistogram[N]{
Temporality: metricdata.CumulativeTemporality,
DataPoints: []metricdata.ExponentialHistogramDataPoint[N]{
{
Count: 6,
Min: metricdata.NewExtrema[N](1),
Max: metricdata.NewExtrema[N](16),
Sum: 31,
Scale: -1,
PositiveBucket: metricdata.ExponentialBucket{
Offset: -1,
Counts: []uint64{1, 4, 1},
DataPoints: []metricdata.ExponentialHistogramDataPoint[N]{},
},
},
},
{
input: []arg[N]{
{ctx, 4, alice},
{ctx, 4, alice},
{ctx, 4, alice},
{ctx, 2, alice},
{ctx, 16, alice},
{ctx, 1, alice},
},
expect: output{
n: 1,
agg: metricdata.ExponentialHistogram[N]{
Temporality: metricdata.CumulativeTemporality,
DataPoints: []metricdata.ExponentialHistogramDataPoint[N]{
{
Attributes: fltrAlice,
StartTime: staticTime,
Time: staticTime,
Count: 6,
Min: metricdata.NewExtrema[N](1),
Max: metricdata.NewExtrema[N](16),
Sum: 31,
Scale: -1,
PositiveBucket: metricdata.ExponentialBucket{
Offset: -1,
Counts: []uint64{1, 4, 1},
},
},
},
},
},
wantCount: 1,
},
{
name: "Delta Multiple",
build: func() (Measure[N], ComputeAggregation) {
return Builder[N]{
Temporality: metricdata.DeltaTemporality,
}.ExponentialBucketHistogram(maxSize, maxScale, noMinMax, noSum)
},
input: [][]N{
{2, 3, 8},
{4, 4, 4, 2, 16, 1},
Comment thread
MrAlias marked this conversation as resolved.
},
want: metricdata.ExponentialHistogram[N]{
Temporality: metricdata.DeltaTemporality,
DataPoints: []metricdata.ExponentialHistogramDataPoint[N]{
{
Count: 6,
Min: metricdata.NewExtrema[N](1),
Max: metricdata.NewExtrema[N](16),
Sum: 31,
Scale: -1,
PositiveBucket: metricdata.ExponentialBucket{
Offset: -1,
Counts: []uint64{1, 4, 1},
input: []arg[N]{
{ctx, 2, alice},
{ctx, 3, alice},
{ctx, 8, alice},
},
expect: output{
n: 1,
agg: metricdata.ExponentialHistogram[N]{
Temporality: metricdata.CumulativeTemporality,
DataPoints: []metricdata.ExponentialHistogramDataPoint[N]{
{
Attributes: fltrAlice,
StartTime: staticTime,
Time: staticTime,
Count: 9,
Min: metricdata.NewExtrema[N](1),
Max: metricdata.NewExtrema[N](16),
Sum: 44,
Scale: -1,
PositiveBucket: metricdata.ExponentialBucket{
Offset: -1,
Counts: []uint64{1, 6, 2},
},
},
},
},
},
wantCount: 1,
},
{
name: "Cumulative Multiple ",
build: func() (Measure[N], ComputeAggregation) {
return Builder[N]{
input: []arg[N]{},
expect: output{
n: 1,
agg: metricdata.ExponentialHistogram[N]{
Temporality: metricdata.CumulativeTemporality,
}.ExponentialBucketHistogram(maxSize, maxScale, noMinMax, noSum)
},
input: [][]N{
{2, 3, 8},
{4, 4, 4, 2, 16, 1},
},
want: metricdata.ExponentialHistogram[N]{
Temporality: metricdata.CumulativeTemporality,
DataPoints: []metricdata.ExponentialHistogramDataPoint[N]{
{
Count: 9,
Min: metricdata.NewExtrema[N](1),
Max: metricdata.NewExtrema[N](16),
Sum: 44,
Scale: -1,
PositiveBucket: metricdata.ExponentialBucket{
Offset: -1,
Counts: []uint64{1, 6, 2},
DataPoints: []metricdata.ExponentialHistogramDataPoint[N]{
{
Attributes: fltrAlice,
StartTime: staticTime,
Time: staticTime,
Count: 9,
Min: metricdata.NewExtrema[N](1),
Max: metricdata.NewExtrema[N](16),
Sum: 44,
Scale: -1,
PositiveBucket: metricdata.ExponentialBucket{
Offset: -1,
Counts: []uint64{1, 6, 2},
},
},
},
},
},
wantCount: 1,
},
}

for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
restore := withHandler(t)
defer restore()
in, out := tt.build()
ctx := context.Background()

var got metricdata.Aggregation
var count int
for _, n := range tt.input {
for _, v := range n {
in(ctx, v, *attribute.EmptySet())
}
count = out(&got)
}

metricdatatest.AssertAggregationsEqual(t, tt.want, got, metricdatatest.IgnoreTimestamp())
assert.Equal(t, tt.wantCount, count)
})
}
})
}

func FuzzGetBin(f *testing.F) {
Expand Down