Skip to content

Commit

Permalink
[chore] Replace usage of metadatatest.SetupTelemetry with new compone…
Browse files Browse the repository at this point in the history 
…ntest (open-telemetry#37613)

Signed-off-by: Bogdan Drutu <[email protected]>
  • Loading branch information
@bogdandrutu
bogdandrutu authored Jan 31, 2025
1 parent c4ec5d2 commit 0af2e2d
Show file tree
Hide file tree
Showing 5 changed files with 290 additions and 924 deletions.
59 changes: 19 additions & 40 deletions exporter/prometheusremotewriteexporter/exporter_test.go
View file
Original file line number Diff line number Diff line change
Expand Up @@ -736,11 +736,7 @@ func Test_PushMetrics(t *testing.T) {
}

assert.NotNil(t, cfg)
buildInfo := component.BuildInfo{
Description: "OpenTelemetry Collector",
Version: "1.0",
}
tel := metadatatest.SetupTelemetry(
tel := componenttest.NewTelemetry(
componenttest.WithMetricOptions(sdkmetric.WithView(
// Drop otelhttp metrics
sdkmetric.NewView(
Expand All @@ -752,8 +748,12 @@ func Test_PushMetrics(t *testing.T) {
},
))),
)
set := tel.NewSettings()
set.BuildInfo = buildInfo
t.Cleanup(func() { require.NoError(t, tel.Shutdown(context.Background())) })
set := metadatatest.NewSettings(tel)
set.BuildInfo = component.BuildInfo{
Description: "OpenTelemetry Collector",
Version: "1.0",
}

prwe, nErr := newPRWExporter(cfg, set)

Expand All @@ -769,42 +769,22 @@ func Test_PushMetrics(t *testing.T) {
assert.Error(t, err)
return
}
expectedMetrics := []metricdata.Metrics{}
assert.NoError(t, err)
if tt.expectedFailedTranslations > 0 {
expectedMetrics = append(expectedMetrics, metricdata.Metrics{
Name: "otelcol_exporter_prometheusremotewrite_failed_translations",
Description: "Number of translation operations that failed to translate metrics from Otel to Prometheus",
Unit: "1",
Data: metricdata.Sum[int64]{
Temporality: metricdata.CumulativeTemporality,
IsMonotonic: true,
DataPoints: []metricdata.DataPoint[int64]{
{
Value: int64(tt.expectedFailedTranslations),
Attributes: attribute.NewSet(attribute.String("exporter", "prometheusremotewrite")),
},
},
metadatatest.AssertEqualExporterPrometheusremotewriteFailedTranslations(t, tel, []metricdata.DataPoint[int64]{
{
Value: int64(tt.expectedFailedTranslations),
Attributes: attribute.NewSet(attribute.String("exporter", "prometheusremotewrite")),
},
})
}, metricdatatest.IgnoreTimestamp())
}

expectedMetrics = append(expectedMetrics, metricdata.Metrics{
Name: "otelcol_exporter_prometheusremotewrite_translated_time_series",
Description: "Number of Prometheus time series that were translated from OTel metrics",
Unit: "1",
Data: metricdata.Sum[int64]{
Temporality: metricdata.CumulativeTemporality,
IsMonotonic: true,
DataPoints: []metricdata.DataPoint[int64]{
{
Value: int64(tt.expectedTimeSeries),
Attributes: attribute.NewSet(attribute.String("exporter", "prometheusremotewrite")),
},
},
metadatatest.AssertEqualExporterPrometheusremotewriteTranslatedTimeSeries(t, tel, []metricdata.DataPoint[int64]{
{
Value: int64(tt.expectedTimeSeries),
Attributes: attribute.NewSet(attribute.String("exporter", "prometheusremotewrite")),
},
})
tel.AssertMetrics(t, expectedMetrics, metricdatatest.IgnoreTimestamp())
assert.NoError(t, err)
}, metricdatatest.IgnoreTimestamp())
})
}
})
Expand Down Expand Up @@ -1306,8 +1286,7 @@ func benchmarkPushMetrics(b *testing.B, numMetrics, numConsumers int) {
endpointURL, err := url.Parse(mockServer.URL)
require.NoError(b, err)

tel := metadatatest.SetupTelemetry()
set := tel.NewSettings()
set := exportertest.NewNopSettings()
// Adjusted retry settings for faster testing
retrySettings := configretry.BackOffConfig{
Enabled: true,
Expand Down
259 changes: 77 additions & 182 deletions processor/groupbyattrsprocessor/processor_test.go
View file
Original file line number Diff line number Diff line change
Expand Up @@ -13,6 +13,7 @@ import (

"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
"go.opentelemetry.io/collector/component/componenttest"
"go.opentelemetry.io/collector/pdata/pcommon"
"go.opentelemetry.io/collector/pdata/plog"
"go.opentelemetry.io/collector/pdata/pmetric"
Expand Down Expand Up @@ -273,8 +274,10 @@ func TestComplexAttributeGrouping(t *testing.T) {
inputMetrics := someComplexMetrics(tt.withResourceAttrIndex, tt.inputResourceCount, tt.inputInstrumentationLibraryCount, 2)
inputHistogramMetrics := someComplexHistogramMetrics(tt.withResourceAttrIndex, tt.inputResourceCount, tt.inputInstrumentationLibraryCount, 2, 2)

tel := metadatatest.SetupTelemetry()
gap, err := createGroupByAttrsProcessor(tel.NewSettings(), tt.groupByKeys)
tel := componenttest.NewTelemetry()
t.Cleanup(func() { require.NoError(t, tel.Shutdown(context.Background())) })

gap, err := createGroupByAttrsProcessor(metadatatest.NewSettings(tel), tt.groupByKeys)
require.NoError(t, err)

processedLogs, err := gap.processLogs(context.Background(), inputLogs)
Expand Down Expand Up @@ -374,213 +377,105 @@ func TestComplexAttributeGrouping(t *testing.T) {
}
}
}
var want []metricdata.Metrics
if tt.shouldMoveCommonGroupedAttr {
want = []metricdata.Metrics{
metadatatest.AssertEqualProcessorGroupbyattrsNumGroupedLogs(t, tel, []metricdata.DataPoint[int64]{
{
Name: "otelcol_processor_groupbyattrs_num_grouped_logs",
Description: "Number of logs that had attributes grouped",
Unit: "1",
Data: metricdata.Sum[int64]{
Temporality: metricdata.CumulativeTemporality,
IsMonotonic: true,
DataPoints: []metricdata.DataPoint[int64]{
{
Value: int64(tt.outputTotalRecordsCount),
},
},
},
Value: int64(tt.outputTotalRecordsCount),
},
}, metricdatatest.IgnoreTimestamp())
metadatatest.AssertEqualProcessorGroupbyattrsNumGroupedMetrics(t, tel, []metricdata.DataPoint[int64]{
{
Name: "otelcol_processor_groupbyattrs_num_grouped_metrics",
Description: "Number of metrics that had attributes grouped",
Unit: "1",
Data: metricdata.Sum[int64]{
Temporality: metricdata.CumulativeTemporality,
IsMonotonic: true,
DataPoints: []metricdata.DataPoint[int64]{
{
Value: 4 * int64(tt.outputTotalRecordsCount),
},
},
},
Value: 4 * int64(tt.outputTotalRecordsCount),
},
}, metricdatatest.IgnoreTimestamp())
metadatatest.AssertEqualProcessorGroupbyattrsNumGroupedSpans(t, tel, []metricdata.DataPoint[int64]{
{
Name: "otelcol_processor_groupbyattrs_num_grouped_spans",
Description: "Number of spans that had attributes grouped",
Unit: "1",
Data: metricdata.Sum[int64]{
Temporality: metricdata.CumulativeTemporality,
IsMonotonic: true,
DataPoints: []metricdata.DataPoint[int64]{
{
Value: int64(tt.outputTotalRecordsCount),
},
},
},
Value: int64(tt.outputTotalRecordsCount),
},
}, metricdatatest.IgnoreTimestamp())
metadatatest.AssertEqualProcessorGroupbyattrsLogGroups(t, tel, []metricdata.HistogramDataPoint[int64]{
{
Name: "otelcol_processor_groupbyattrs_log_groups",
Description: "Distribution of groups extracted for logs",
Unit: "1",
Data: metricdata.Histogram[int64]{
Temporality: metricdata.CumulativeTemporality,
DataPoints: []metricdata.HistogramDataPoint[int64]{
{
Attributes: *attribute.EmptySet(),
Bounds: []float64{0, 5, 10, 25, 50, 75, 100, 250, 500, 750, 1000, 2500, 5000, 7500, 10000},
BucketCounts: []uint64{0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
Count: 1,
Min: metricdata.NewExtrema(int64(tt.outputResourceCount)),
Max: metricdata.NewExtrema(int64(tt.outputResourceCount)),
Sum: int64(tt.outputResourceCount),
},
},
},
Attributes: *attribute.EmptySet(),
Bounds: []float64{0, 5, 10, 25, 50, 75, 100, 250, 500, 750, 1000, 2500, 5000, 7500, 10000},
BucketCounts: []uint64{0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
Count: 1,
Min: metricdata.NewExtrema(int64(tt.outputResourceCount)),
Max: metricdata.NewExtrema(int64(tt.outputResourceCount)),
Sum: int64(tt.outputResourceCount),
},
}, metricdatatest.IgnoreTimestamp())
metadatatest.AssertEqualProcessorGroupbyattrsMetricGroups(t, tel, []metricdata.HistogramDataPoint[int64]{
{
Name: "otelcol_processor_groupbyattrs_metric_groups",
Description: "Distribution of groups extracted for metrics",
Unit: "1",
Data: metricdata.Histogram[int64]{
Temporality: metricdata.CumulativeTemporality,
DataPoints: []metricdata.HistogramDataPoint[int64]{
{
Attributes: *attribute.EmptySet(),
Bounds: []float64{0, 5, 10, 25, 50, 75, 100, 250, 500, 750, 1000, 2500, 5000, 7500, 10000},
BucketCounts: []uint64{0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
Count: 2,
Min: metricdata.NewExtrema(int64(tt.outputResourceCount)),
Max: metricdata.NewExtrema(int64(tt.outputResourceCount)),
Sum: 2 * int64(tt.outputResourceCount),
},
},
},
Attributes: *attribute.EmptySet(),
Bounds: []float64{0, 5, 10, 25, 50, 75, 100, 250, 500, 750, 1000, 2500, 5000, 7500, 10000},
BucketCounts: []uint64{0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
Count: 2,
Min: metricdata.NewExtrema(int64(tt.outputResourceCount)),
Max: metricdata.NewExtrema(int64(tt.outputResourceCount)),
Sum: 2 * int64(tt.outputResourceCount),
},
}, metricdatatest.IgnoreTimestamp())
metadatatest.AssertEqualProcessorGroupbyattrsSpanGroups(t, tel, []metricdata.HistogramDataPoint[int64]{
{
Name: "otelcol_processor_groupbyattrs_span_groups",
Description: "Distribution of groups extracted for spans",
Unit: "1",
Data: metricdata.Histogram[int64]{
Temporality: metricdata.CumulativeTemporality,
DataPoints: []metricdata.HistogramDataPoint[int64]{
{
Attributes: *attribute.EmptySet(),
Bounds: []float64{0, 5, 10, 25, 50, 75, 100, 250, 500, 750, 1000, 2500, 5000, 7500, 10000},
BucketCounts: []uint64{0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
Count: 1,
Min: metricdata.NewExtrema(int64(tt.outputResourceCount)),
Max: metricdata.NewExtrema(int64(tt.outputResourceCount)),
Sum: int64(tt.outputResourceCount),
},
},
},
Attributes: *attribute.EmptySet(),
Bounds: []float64{0, 5, 10, 25, 50, 75, 100, 250, 500, 750, 1000, 2500, 5000, 7500, 10000},
BucketCounts: []uint64{0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
Count: 1,
Min: metricdata.NewExtrema(int64(tt.outputResourceCount)),
Max: metricdata.NewExtrema(int64(tt.outputResourceCount)),
Sum: int64(tt.outputResourceCount),
},
}
}, metricdatatest.IgnoreTimestamp())
} else {
want = []metricdata.Metrics{
metadatatest.AssertEqualProcessorGroupbyattrsNumNonGroupedLogs(t, tel, []metricdata.DataPoint[int64]{
{
Name: "otelcol_processor_groupbyattrs_num_non_grouped_logs",
Description: "Number of logs that did not have attributes grouped",
Unit: "1",
Data: metricdata.Sum[int64]{
Temporality: metricdata.CumulativeTemporality,
IsMonotonic: true,
DataPoints: []metricdata.DataPoint[int64]{
{
Value: int64(tt.outputTotalRecordsCount),
},
},
},
Value: int64(tt.outputTotalRecordsCount),
},
}, metricdatatest.IgnoreTimestamp())
metadatatest.AssertEqualProcessorGroupbyattrsNumNonGroupedMetrics(t, tel, []metricdata.DataPoint[int64]{
{
Name: "otelcol_processor_groupbyattrs_num_non_grouped_metrics",
Description: "Number of metrics that did not have attributes grouped",
Unit: "1",
Data: metricdata.Sum[int64]{
Temporality: metricdata.CumulativeTemporality,
IsMonotonic: true,
DataPoints: []metricdata.DataPoint[int64]{
{
Value: 4 * int64(tt.outputTotalRecordsCount),
},
},
},
Value: 4 * int64(tt.outputTotalRecordsCount),
},
}, metricdatatest.IgnoreTimestamp())
metadatatest.AssertEqualProcessorGroupbyattrsNumNonGroupedSpans(t, tel, []metricdata.DataPoint[int64]{
{
Name: "otelcol_processor_groupbyattrs_num_non_grouped_spans",
Description: "Number of spans that did not have attributes grouped",
Unit: "1",
Data: metricdata.Sum[int64]{
Temporality: metricdata.CumulativeTemporality,
IsMonotonic: true,
DataPoints: []metricdata.DataPoint[int64]{
{
Value: int64(tt.outputTotalRecordsCount),
},
},
},
Value: int64(tt.outputTotalRecordsCount),
},
}, metricdatatest.IgnoreTimestamp())
metadatatest.AssertEqualProcessorGroupbyattrsLogGroups(t, tel, []metricdata.HistogramDataPoint[int64]{
{
Name: "otelcol_processor_groupbyattrs_log_groups",
Description: "Distribution of groups extracted for logs",
Unit: "1",
Data: metricdata.Histogram[int64]{
Temporality: metricdata.CumulativeTemporality,
DataPoints: []metricdata.HistogramDataPoint[int64]{
{
Attributes: *attribute.EmptySet(),
Bounds: []float64{0, 5, 10, 25, 50, 75, 100, 250, 500, 750, 1000, 2500, 5000, 7500, 10000},
BucketCounts: []uint64{0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
Count: 1,
Min: metricdata.NewExtrema(int64(tt.outputResourceCount)),
Max: metricdata.NewExtrema(int64(tt.outputResourceCount)),
Sum: int64(tt.outputResourceCount),
},
},
},
Attributes: *attribute.EmptySet(),
Bounds: []float64{0, 5, 10, 25, 50, 75, 100, 250, 500, 750, 1000, 2500, 5000, 7500, 10000},
BucketCounts: []uint64{0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
Count: 1,
Min: metricdata.NewExtrema(int64(tt.outputResourceCount)),
Max: metricdata.NewExtrema(int64(tt.outputResourceCount)),
Sum: int64(tt.outputResourceCount),
},
}, metricdatatest.IgnoreTimestamp())
metadatatest.AssertEqualProcessorGroupbyattrsMetricGroups(t, tel, []metricdata.HistogramDataPoint[int64]{
{
Name: "otelcol_processor_groupbyattrs_metric_groups",
Description: "Distribution of groups extracted for metrics",
Unit: "1",
Data: metricdata.Histogram[int64]{
Temporality: metricdata.CumulativeTemporality,
DataPoints: []metricdata.HistogramDataPoint[int64]{
{
Attributes: *attribute.EmptySet(),
Bounds: []float64{0, 5, 10, 25, 50, 75, 100, 250, 500, 750, 1000, 2500, 5000, 7500, 10000},
BucketCounts: []uint64{0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
Count: 2,
Min: metricdata.NewExtrema(int64(tt.outputResourceCount)),
Max: metricdata.NewExtrema(int64(tt.outputResourceCount)),
Sum: 2 * int64(tt.outputResourceCount),
},
},
},
Attributes: *attribute.EmptySet(),
Bounds: []float64{0, 5, 10, 25, 50, 75, 100, 250, 500, 750, 1000, 2500, 5000, 7500, 10000},
BucketCounts: []uint64{0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
Count: 2,
Min: metricdata.NewExtrema(int64(tt.outputResourceCount)),
Max: metricdata.NewExtrema(int64(tt.outputResourceCount)),
Sum: 2 * int64(tt.outputResourceCount),
},
}, metricdatatest.IgnoreTimestamp())
metadatatest.AssertEqualProcessorGroupbyattrsSpanGroups(t, tel, []metricdata.HistogramDataPoint[int64]{
{
Name: "otelcol_processor_groupbyattrs_span_groups",
Description: "Distribution of groups extracted for spans",
Unit: "1",
Data: metricdata.Histogram[int64]{
Temporality: metricdata.CumulativeTemporality,
DataPoints: []metricdata.HistogramDataPoint[int64]{
{
Attributes: *attribute.EmptySet(),
Bounds: []float64{0, 5, 10, 25, 50, 75, 100, 250, 500, 750, 1000, 2500, 5000, 7500, 10000},
BucketCounts: []uint64{0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
Count: 1,
Min: metricdata.NewExtrema(int64(tt.outputResourceCount)),
Max: metricdata.NewExtrema(int64(tt.outputResourceCount)),
Sum: int64(tt.outputResourceCount),
},
},
},
Attributes: *attribute.EmptySet(),
Bounds: []float64{0, 5, 10, 25, 50, 75, 100, 250, 500, 750, 1000, 2500, 5000, 7500, 10000},
BucketCounts: []uint64{0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
Count: 1,
Min: metricdata.NewExtrema(int64(tt.outputResourceCount)),
Max: metricdata.NewExtrema(int64(tt.outputResourceCount)),
Sum: int64(tt.outputResourceCount),
},
}
}, metricdatatest.IgnoreTimestamp())
}
tel.AssertMetrics(t, want, metricdatatest.IgnoreTimestamp())
})
}
}
Expand Down
Loading

0 comments on commit 0af2e2d

Please sign in to comment.