[pkg/testdata] Add function for profiles validation

Author: rockdaboot

pkg/pdatatest/pprofiletest/profiles.go

@@ -181,11 +181,13 @@ func CompareScopeProfiles(expected, actual pprofile.ScopeProfiles) error {
 	var outOfOrderErrs error
 	for e := 0; e < numProfiles; e++ {
 		elr := expected.Profiles().At(e)
+		errs = multierr.Append(errs, ValidateProfile(elr))
 		em := profileAttributesToMap(elr)
 
 		var foundMatch bool
 		for a := 0; a < numProfiles; a++ {
 			alr := actual.Profiles().At(a)
+			errs = multierr.Append(errs, ValidateProfile(alr))
 			if _, ok := matchingProfiles[alr]; ok {
 				continue
 			}
@@ -266,7 +268,7 @@ func CompareProfile(expected, actual pprofile.Profile) error {
 	}
 
 	if !reflect.DeepEqual(expected.StringTable(), actual.StringTable()) {
-		errs = multierr.Append(errs, fmt.Errorf("stringTable does not match expected"))
+		errs = multierr.Append(errs, fmt.Errorf("stringTable '%v' does not match expected '%v'", actual.StringTable().AsRaw(), expected.StringTable().AsRaw()))
 	}
 
 	if expected.OriginalPayloadFormat() != actual.OriginalPayloadFormat() {

pkg/pdatatest/pprofiletest/profiles_test.go

@@ -707,7 +707,7 @@ func TestCompareProfile(t *testing.T) {
 			}(),
 			err: multierr.Combine(
 				errors.New(`attributes don't match expected: map[key:val], actual: map[key1:val1]`),
-				errors.New(`stringTable does not match expected`),
+				errors.New(`stringTable '[ cpu1 nanoseconds1 samples count samples1 count1 cpu2 nanoseconds2]' does not match expected '[ cpu nanoseconds samples count]'`),
 				errors.New(`period does not match expected '1', actual '2'`),
 				fmt.Errorf(`sampleType: %w`, fmt.Errorf(`missing expected valueType "unit: 4, type: 3, aggregationTemporality: 1"`)),
 				fmt.Errorf(`sampleType: %w`, fmt.Errorf(`unexpected valueType "unit: 6, type: 5, aggregationTemporality: 1"`)),

pkg/pdatatest/pprofiletest/validate.go

@@ -0,0 +1,238 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+package pprofiletest // import "github.com/open-telemetry/opentelemetry-collector-contrib/pkg/pdatatest/pprofiletest"
+import (
+	"errors"
+	"fmt"
+
+	"go.opentelemetry.io/collector/pdata/pcommon"
+	"go.opentelemetry.io/collector/pdata/pprofile"
+)
+
+func ValidateProfile(pp pprofile.Profile) error {
+	stLen := pp.StringTable().Len()
+	if stLen < 1 {
+		return fmt.Errorf("empty string table, must at least contain the empty string")
+	}
+	if pp.StringTable().At(0) != "" {
+		return fmt.Errorf("string table must start with the empty string")
+	}
+
+	if pp.SampleType().Len() < 1 {
+		// Since the proto field 'default_sample_type_index' is always valid, there must be at least
+		// one sample type in the profile.
+		return fmt.Errorf("missing sample type, need at least a default")
+	}
+
+	if err := validateSampleType(pp); err != nil {
+		return err
+	}
+
+	if err := validateSample(pp); err != nil {
+		return err
+	}
+
+	if err := validateValueType(stLen, pp.PeriodType()); err != nil {
+		return fmt.Errorf("period_type: %w", err)
+	}
+
+	if err := validateIndex(stLen, pp.DefaultSampleTypeStrindex()); err != nil {
+		return fmt.Errorf("default_sample_type_strindex: %w", err)
+	}
+
+	if err := validateIndices(stLen, pp.CommentStrindices()); err != nil {
+		return fmt.Errorf("comment_strindices: %w", err)
+	}
+
+	if err := validateIndices(pp.AttributeTable().Len(), pp.AttributeIndices()); err != nil {
+		return fmt.Errorf("attribute_indices: %w", err)
+	}
+
+	if err := validateAttributeUnits(pp); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func validateIndices(length int, indices pcommon.Int32Slice) error {
+	for i := range indices.Len() {
+		if err := validateIndex(length, indices.At(i)); err != nil {
+			return fmt.Errorf("[%d]: %w", i, err)
+		}
+	}
+	return nil
+}
+
+func validateIndex(length int, idx int32) error {
+	if idx < 0 || int(idx) >= length {
+		return fmt.Errorf("index %d is out of range [0..%d)",
+			idx, length)
+	}
+	return nil
+}
+
+func validateSampleType(pp pprofile.Profile) error {
+	stLen := pp.StringTable().Len()
+	for i := range pp.SampleType().Len() {
+		if err := validateValueType(stLen, pp.SampleType().At(i)); err != nil {
+			return fmt.Errorf("sample_type[%d]: %w", i, err)
+		}
+	}
+	return nil
+}
+
+func validateValueType(stLen int, pvt pprofile.ValueType) error {
+	if err := validateIndex(stLen, pvt.TypeStrindex()); err != nil {
+		return fmt.Errorf("type_strindex: %w", err)
+	}
+	if err := validateIndex(stLen, pvt.UnitStrindex()); err != nil {
+		return fmt.Errorf("unit_strindex: %w", err)
+	}
+	if pvt.AggregationTemporality() != pprofile.AggregationTemporalityDelta &&
+		pvt.AggregationTemporality() != pprofile.AggregationTemporalityCumulative {
+		return fmt.Errorf("aggregation_temporality %d is invalid",
+			pvt.AggregationTemporality())
+	}
+	return nil
+}
+
+func validateSample(pp pprofile.Profile) error {
+	for i := range pp.Sample().Len() {
+		if err := validateSampleAt(pp, i); err != nil {
+			return fmt.Errorf("sample[%d]: %w", i, err)
+		}
+	}
+	return nil
+}
+
+func validateSampleAt(pp pprofile.Profile, idx int) error {
+	sample := pp.Sample().At(idx)
+
+	numValues := pp.SampleType().Len()
+	if sample.Value().Len() != numValues {
+		return fmt.Errorf("value length %d does not match sample_type length=%d",
+			sample.Value().Len(), numValues)
+	}
+
+	length := sample.LocationsLength()
+	if length < 0 {
+		return fmt.Errorf("locations_length %d is negative", length)
+	}
+
+	start := sample.LocationsStartIndex()
+	if err := validateIndex(pp.LocationIndices().Len(), start); err != nil {
+		return fmt.Errorf("locations_start_index: %w", err)
+	}
+
+	end := start + length
+	if err := validateIndex(pp.LocationIndices().Len(), end); err != nil {
+		return fmt.Errorf("locations end (%d+%d): %w", start, length, err)
+	}
+
+	for i := start; i < end; i++ {
+		locIdx := pp.LocationIndices().At(int(i))
+		if err := validateIndex(pp.LocationTable().Len(), locIdx); err != nil {
+			return fmt.Errorf("location_indices[%d]: %w", i, err)
+		}
+		if err := validateLocation(pp, pp.LocationTable().At(int(locIdx))); err != nil {
+			return fmt.Errorf("locations[%d]: %w", i, err)
+		}
+	}
+
+	if err := validateIndices(pp.AttributeTable().Len(), sample.AttributeIndices()); err != nil {
+		return fmt.Errorf("attribute_indices: %w", err)
+	}
+
+	startTime := uint64(pp.Time().AsTime().UnixNano())
+	endTime := startTime + uint64(pp.Duration().AsTime().UnixNano())
+	for i := range sample.TimestampsUnixNano().Len() {
+		ts := sample.TimestampsUnixNano().At(i)
+		if ts < startTime || ts >= endTime {
+			return fmt.Errorf("timestamps_unix_nano[%d] %d is out of range [%d..%d)",
+				i, ts, startTime, endTime)
+		}
+	}
+
+	if sample.HasLinkIndex() {
+		if err := validateIndex(pp.LinkTable().Len(), sample.LinkIndex()); err != nil {
+			return fmt.Errorf("link_index: %w", err)
+		}
+	}
+
+	return nil
+}
+
+func validateLocation(pp pprofile.Profile, loc pprofile.Location) error {
+	var errs error
+
+	if err := validateIndex(pp.MappingTable().Len(), loc.MappingIndex()); err != nil {
+		// Continuing would run into a panic.
+		return fmt.Errorf("mapping_index: %w", err)
+	}
+
+	if err := validateMapping(pp, pp.MappingTable().At(int(loc.MappingIndex()))); err != nil {
+		errs = errors.Join(errs, fmt.Errorf("mapping: %w", err))
+	}
+
+	for i := range loc.Line().Len() {
+		if err := validateLine(pp, loc.Line().At(i)); err != nil {
+			errs = errors.Join(errs, fmt.Errorf("line[%d]: %w", i, err))
+		}
+	}
+
+	if err := validateIndices(pp.AttributeTable().Len(), loc.AttributeIndices()); err != nil {
+		errs = errors.Join(errs, fmt.Errorf("attribute_indices: %w", err))
+	}
+
+	return errs
+}
+
+func validateLine(pp pprofile.Profile, line pprofile.Line) error {
+	if err := validateIndex(pp.FunctionTable().Len(), line.FunctionIndex()); err != nil {
+		return fmt.Errorf("function_index: %w", err)
+	}
+
+	return nil
+}
+
+func validateMapping(pp pprofile.Profile, mapping pprofile.Mapping) error {
+	var errs error
+
+	if err := validateIndex(pp.StringTable().Len(), mapping.FilenameStrindex()); err != nil {
+		errs = errors.Join(errs, fmt.Errorf("filename_strindex: %w", err))
+	}
+
+	if err := validateIndices(pp.AttributeTable().Len(), mapping.AttributeIndices()); err != nil {
+		errs = errors.Join(errs, fmt.Errorf("attribute_indices: %w", err))
+	}
+
+	return errs
+}
+
+func validateAttributeUnits(pp pprofile.Profile) error {
+	var errs error
+
+	for i := range pp.AttributeUnits().Len() {
+		if err := validateAttributeUnit(pp, pp.AttributeUnits().At(i)); err != nil {
+			errs = errors.Join(errs, fmt.Errorf("attribute_units[%d]: %w", i, err))
+		}
+	}
+
+	return errs
+}
+
+func validateAttributeUnit(pp pprofile.Profile, au pprofile.AttributeUnit) error {
+	var errs error
+
+	if err := validateIndex(pp.StringTable().Len(), au.AttributeKeyStrindex()); err != nil {
+		errs = errors.Join(errs, fmt.Errorf("attribute_key: %w", err))
+	}
+
+	if err := validateIndex(pp.StringTable().Len(), au.UnitStrindex()); err != nil {
+		errs = errors.Join(errs, fmt.Errorf("unit: %w", err))
+	}
+
+	return errs
+}