[chore][exporter/sumologic]: add deduplicateErrors and `decomposeHi…

…stograms` functions (#32316)

**Description:**

Adds files from Sumo Logic Distribution for OpenTelemetry which are new
in order to simplify review and make simpler to move the whole
component.

This PR is made to simplify #32315

**Link to tracking Issue:**

#31479

**Testing:**

Unit Tests, also this code is use by our customers and internally. It is
not used by now by the component, but will be when migration will be
finished

**Documentation:** N/A

Signed-off-by: Dominik Rosiek <[email protected]>

exporter/sumologicexporter/deduplicate_errors.go

@@ -0,0 +1,49 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+package sumologicexporter // import "github.com/open-telemetry/opentelemetry-collector-contrib/exporter/sumologicexporter"
+
+import "fmt"
+
+// deduplicateErrors replaces duplicate instances of the same error in a slice
+// with a single error containing the number of times it occurred added as a suffix.
+// For example, three occurrences of "error: 502 Bad Gateway"
+// are replaced with a single instance of "error: 502 Bad Gateway (x3)".
+func deduplicateErrors(errs []error) []error {
+ if len(errs) < 2 {
+ return errs
+ }
+
+ errorsWithCounts := []errorWithCount{}
+ for _, err := range errs {
+ found := false
+ for i := range errorsWithCounts {
+ if errorsWithCounts[i].err.Error() == err.Error() {
+ found = true
+ errorsWithCounts[i].count++
+ break
+ }
+ }
+ if !found {
+ errorsWithCounts = append(errorsWithCounts, errorWithCount{
+ err: err,
+ count: 1,
+ })
+ }
+ }
+
+ var uniqueErrors []error
+ for _, errorWithCount := range errorsWithCounts {
+ if errorWithCount.count == 1 {
+ uniqueErrors = append(uniqueErrors, errorWithCount.err)
+ } else {
+ uniqueErrors = append(uniqueErrors, fmt.Errorf("%s (x%d)", errorWithCount.err.Error(), errorWithCount.count))
+ }
+ }
+ return uniqueErrors
+}
+
+type errorWithCount struct {
+ err error
+ count int
+}

exporter/sumologicexporter/deduplicate_errors_test.go

@@ -0,0 +1,58 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+package sumologicexporter // import "github.com/open-telemetry/opentelemetry-collector-contrib/exporter/sumologicexporter"
+
+import (
+ "errors"
+ "testing"
+
+ "github.com/stretchr/testify/assert"
+)
+
+func TestDeduplicateErrors(t *testing.T) {
+ testCases := []struct {
+ name string
+ errs []error
+ expected []error
+ }{
+ {
+ name: "nil is returned as nil",
+ errs: nil,
+ expected: nil,
+ },
+ {
+ name: "single error is returned as-is",
+ errs: []error{
+ errors.New("Single error"),
+ },
+ expected: []error{
+ errors.New("Single error"),
+ },
+ },
+ {
+ name: "duplicates are removed",
+ errs: []error{
+ errors.New("failed sending data: 502 Bad Gateway"),
+ errors.New("failed sending data: 400 Bad Request"),
+ errors.New("failed sending data: 502 Bad Gateway"),
+ errors.New("failed sending data: 400 Bad Request"),
+ errors.New("failed sending data: 400 Bad Request"),
+ errors.New("failed sending data: 400 Bad Request"),
+ errors.New("failed sending data: 504 Gateway Timeout"),
+ errors.New("failed sending data: 502 Bad Gateway"),
+ },
+ expected: []error{
+ errors.New("failed sending data: 502 Bad Gateway (x3)"),
+ errors.New("failed sending data: 400 Bad Request (x4)"),
+ errors.New("failed sending data: 504 Gateway Timeout"),
+ },
+ },
+ }
+
+ for _, testCase := range testCases {
+ t.Run(testCase.name, func(t *testing.T) {
+ assert.Equal(t, testCase.expected, deduplicateErrors(testCase.errs))
+ })
+ }
+}

exporter/sumologicexporter/otlp.go

@@ -0,0 +1,149 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+package sumologicexporter // import "github.com/open-telemetry/opentelemetry-collector-contrib/exporter/sumologicexporter"
+
+import (
+ "math"
+
+ "go.opentelemetry.io/collector/pdata/pmetric"
+)
+
+// decomposeHistograms decomposes any histograms present in the metric data into individual Sums and Gauges
+// This is a noop if no Histograms are present, but otherwise makes a copy of the whole structure
+// This exists because Sumo doesn't support OTLP histograms yet, and has the same semantics as the conversion to Prometheus format in prometheus_formatter.go
+func decomposeHistograms(md pmetric.Metrics) pmetric.Metrics {
+ // short circuit and do nothing if no Histograms are present
+ foundHistogram := false
+outer:
+ for i := 0; i < md.ResourceMetrics().Len(); i++ {
+ resourceMetric := md.ResourceMetrics().At(i)
+ for j := 0; j < resourceMetric.ScopeMetrics().Len(); j++ {
+ scopeMetric := resourceMetric.ScopeMetrics().At(j)
+ for k := 0; k < scopeMetric.Metrics().Len(); k++ {
+ foundHistogram = scopeMetric.Metrics().At(k).Type() == pmetric.MetricTypeHistogram
+ if foundHistogram {
+ break outer
+ }
+ }
+ }
+ }
+ if !foundHistogram {
+ return md
+ }
+
+ decomposed := pmetric.NewMetrics()
+ md.CopyTo(decomposed)
+
+ for i := 0; i < decomposed.ResourceMetrics().Len(); i++ {
+ resourceMetric := decomposed.ResourceMetrics().At(i)
+ for j := 0; j < resourceMetric.ScopeMetrics().Len(); j++ {
+ metrics := resourceMetric.ScopeMetrics().At(j).Metrics()
+ for k := 0; k < metrics.Len(); k++ {
+ metric := metrics.At(k)
+ if metric.Type() == pmetric.MetricTypeHistogram {
+ decomposedHistogram := decomposeHistogram(metric)
+ decomposedHistogram.MoveAndAppendTo(metrics)
+ }
+ }
+ metrics.RemoveIf(func(m pmetric.Metric) bool { return m.Type() == pmetric.MetricTypeHistogram })
+ }
+ }
+
+ return decomposed
+}
+
+// decomposeHistogram decomposes a single Histogram metric into individual metrics for count, bucket and sum
+// non-Histograms give an empty slice as output
+func decomposeHistogram(metric pmetric.Metric) pmetric.MetricSlice {
+ output := pmetric.NewMetricSlice()
+ if metric.Type() != pmetric.MetricTypeHistogram {
+ return output
+ }
+
+ getHistogramSumMetric(metric).MoveTo(output.AppendEmpty())
+ getHistogramCountMetric(metric).MoveTo(output.AppendEmpty())
+ getHistogramBucketsMetric(metric).MoveTo(output.AppendEmpty())
+
+ return output
+}
+
+func getHistogramBucketsMetric(metric pmetric.Metric) pmetric.Metric {
+ histogram := metric.Histogram()
+
+ bucketsMetric := pmetric.NewMetric()
+ bucketsMetric.SetName(metric.Name() + "_bucket")
+ bucketsMetric.SetDescription(metric.Description())
+ bucketsMetric.SetUnit(metric.Unit())
+ bucketsMetric.SetEmptyGauge()
+ bucketsDatapoints := bucketsMetric.Gauge().DataPoints()
+
+ for i := 0; i < histogram.DataPoints().Len(); i++ {
+ histogramDataPoint := histogram.DataPoints().At(i)
+ histogramBounds := histogramDataPoint.ExplicitBounds()
+ var cumulative uint64
+
+ for j := 0; j < histogramBounds.Len(); j++ {
+ bucketDataPoint := bucketsDatapoints.AppendEmpty()
+ bound := histogramBounds.At(j)
+ histogramDataPoint.Attributes().CopyTo(bucketDataPoint.Attributes())
+ bucketDataPoint.Attributes().PutDouble(prometheusLeTag, bound)
+ bucketDataPoint.SetStartTimestamp(histogramDataPoint.StartTimestamp())
+ bucketDataPoint.SetTimestamp(histogramDataPoint.Timestamp())
+ cumulative += histogramDataPoint.BucketCounts().At(j)
+ bucketDataPoint.SetIntValue(int64(cumulative))
+ }
+
+ // need to add one more bucket at +Inf
+ bucketDataPoint := bucketsDatapoints.AppendEmpty()
+ histogramDataPoint.Attributes().CopyTo(bucketDataPoint.Attributes())
+ bucketDataPoint.Attributes().PutDouble(prometheusLeTag, math.Inf(1))
+ bucketDataPoint.SetStartTimestamp(histogramDataPoint.StartTimestamp())
+ bucketDataPoint.SetTimestamp(histogramDataPoint.Timestamp())
+ cumulative += histogramDataPoint.BucketCounts().At(histogramDataPoint.ExplicitBounds().Len())
+ bucketDataPoint.SetIntValue(int64(cumulative))
+ }
+ return bucketsMetric
+}
+
+func getHistogramSumMetric(metric pmetric.Metric) pmetric.Metric {
+ histogram := metric.Histogram()
+
+ sumMetric := pmetric.NewMetric()
+ sumMetric.SetName(metric.Name() + "_sum")
+ sumMetric.SetDescription(metric.Description())
+ sumMetric.SetUnit(metric.Unit())
+ sumMetric.SetEmptyGauge()
+ sumDataPoints := sumMetric.Gauge().DataPoints()
+
+ for i := 0; i < histogram.DataPoints().Len(); i++ {
+ histogramDataPoint := histogram.DataPoints().At(i)
+ sumDataPoint := sumDataPoints.AppendEmpty()
+ histogramDataPoint.Attributes().CopyTo(sumDataPoint.Attributes())
+ sumDataPoint.SetStartTimestamp(histogramDataPoint.StartTimestamp())
+ sumDataPoint.SetTimestamp(histogramDataPoint.Timestamp())
+ sumDataPoint.SetDoubleValue(histogramDataPoint.Sum())
+ }
+ return sumMetric
+}
+
+func getHistogramCountMetric(metric pmetric.Metric) pmetric.Metric {
+ histogram := metric.Histogram()
+
+ countMetric := pmetric.NewMetric()
+ countMetric.SetName(metric.Name() + "_count")
+ countMetric.SetDescription(metric.Description())
+ countMetric.SetUnit(metric.Unit())
+ countMetric.SetEmptyGauge()
+ countDataPoints := countMetric.Gauge().DataPoints()
+
+ for i := 0; i < histogram.DataPoints().Len(); i++ {
+ histogramDataPoint := histogram.DataPoints().At(i)
+ countDataPoint := countDataPoints.AppendEmpty()
+ histogramDataPoint.Attributes().CopyTo(countDataPoint.Attributes())
+ countDataPoint.SetStartTimestamp(histogramDataPoint.StartTimestamp())
+ countDataPoint.SetTimestamp(histogramDataPoint.Timestamp())
+ countDataPoint.SetIntValue(int64(histogramDataPoint.Count()))
+ }
+ return countMetric
+}