[pkg/ottl]: Create ctxprofilecommon for common attribute handling in various profiling sub messages

Most Profiling messages do have some attributes. Create ctxprofilecommon for shared functionality.

Signed-off-by: Florian Lehner <florian.lehner@elastic.co>

Author: florianl

.chloggen/ctxprofilecommon.yaml

@@ -0,0 +1,27 @@
+# Use this changelog template to create an entry for release notes.
+
+# One of 'breaking', 'deprecation', 'new_component', 'enhancement', 'bug_fix'
+change_type: enhancement
+
+# The name of the component, or a single word describing the area of concern, (e.g. filelogreceiver)
+component: pkg/ottl
+
+# A brief description of the change.  Surround your text with quotes ("") if it needs to start with a backtick (`).
+note: Create ctxprofilecommon for common attribute handling in various profiling sub messages
+
+# Mandatory: One or more tracking issues related to the change. You can use the PR number here if no issue exists.
+issues: []
+
+# (Optional) One or more lines of additional information to render under the primary note.
+# These lines will be padded with 2 spaces and then inserted directly into the document.
+# Use pipe (|) for multiline entries.
+subtext:
+
+# If your change doesn't affect end users or the exported elements of any package,
+# you should instead start your pull request title with [chore] or use the "Skip Changelog" label.
+# Optional: The change log or logs in which this entry should be included.
+# e.g. '[user]' or '[user, api]'
+# Include 'user' if the change is relevant to end users.
+# Include 'api' if there is a change to a library API.
+# Default: '[user]'
+change_logs: [api]

pkg/ottl/contexts/internal/ctxprofile/context.go

@@ -3,6 +3,7 @@
 
 package ctxprofile // import "github.com/open-telemetry/opentelemetry-collector-contrib/pkg/ottl/contexts/internal/ctxprofile"
 import (
+	"go.opentelemetry.io/collector/pdata/pcommon"
 	"go.opentelemetry.io/collector/pdata/pprofile"
 )
 
@@ -12,6 +13,7 @@ const (
 )
 
 type Context interface {
+	AttributeIndices() pcommon.Int32Slice
 	GetProfile() pprofile.Profile
 	GetProfilesDictionary() pprofile.ProfilesDictionary
 }

pkg/ottl/contexts/internal/ctxprofile/profile.go

@@ -15,6 +15,7 @@ import (
 	"github.com/open-telemetry/opentelemetry-collector-contrib/pkg/ottl"
 	"github.com/open-telemetry/opentelemetry-collector-contrib/pkg/ottl/contexts/internal/ctxcommon"
 	"github.com/open-telemetry/opentelemetry-collector-contrib/pkg/ottl/contexts/internal/ctxerror"
+	"github.com/open-telemetry/opentelemetry-collector-contrib/pkg/ottl/contexts/internal/ctxprofilecommon"
 	"github.com/open-telemetry/opentelemetry-collector-contrib/pkg/ottl/contexts/internal/ctxutil"
 )
 
@@ -64,9 +65,9 @@ func PathGetSetter[K Context](path ottl.Path[K]) (ottl.GetSetter[K], error) {
 		return accessOriginalPayload[K](), nil
 	case "attributes":
 		if path.Keys() == nil {
-			return accessAttributes[K](), nil
+			return ctxprofilecommon.AccessAttributes[K](), nil
 		}
-		return accessAttributesKey(path.Keys()), nil
+		return ctxprofilecommon.AccessAttributesKey[K](path.Keys()), nil
 	default:
 		return nil, ctxerror.New(path.Name(), path.String(), Name, DocRef)
 	}
@@ -311,62 +312,3 @@ func accessOriginalPayload[K Context]() ottl.StandardGetSetter[K] {
 		},
 	}
 }
-
-func accessAttributes[K Context]() ottl.StandardGetSetter[K] {
-	return ottl.StandardGetSetter[K]{
-		Getter: func(_ context.Context, tCtx K) (any, error) {
-			return pprofile.FromAttributeIndices(tCtx.GetProfilesDictionary().AttributeTable(), tCtx.GetProfile()), nil
-		},
-		Setter: func(_ context.Context, tCtx K, val any) error {
-			m, err := ctxutil.GetMap(val)
-			if err != nil {
-				return err
-			}
-			tCtx.GetProfile().AttributeIndices().FromRaw([]int32{})
-			for k, v := range m.All() {
-				if err := pprofile.PutAttribute(tCtx.GetProfilesDictionary().AttributeTable(), tCtx.GetProfile(), k, v); err != nil {
-					return err
-				}
-			}
-			return nil
-		},
-	}
-}
-
-func accessAttributesKey[K Context](key []ottl.Key[K]) ottl.StandardGetSetter[K] {
-	return ottl.StandardGetSetter[K]{
-		Getter: func(ctx context.Context, tCtx K) (any, error) {
-			return ctxutil.GetMapValue[K](ctx, tCtx, pprofile.FromAttributeIndices(tCtx.GetProfilesDictionary().AttributeTable(), tCtx.GetProfile()), key)
-		},
-		Setter: func(ctx context.Context, tCtx K, val any) error {
-			newKey, err := ctxutil.GetMapKeyName(ctx, tCtx, key[0])
-			if err != nil {
-				return err
-			}
-			v := getAttributeValue(tCtx, *newKey)
-			err = ctxutil.SetIndexableValue[K](ctx, tCtx, v, val, key[1:])
-			if err != nil {
-				return err
-			}
-			return pprofile.PutAttribute(tCtx.GetProfilesDictionary().AttributeTable(), tCtx.GetProfile(), *newKey, v)
-		},
-	}
-}
-
-func getAttributeValue[K Context](tCtx K, key string) pcommon.Value {
-	// Find the index of the attribute in the profile's attribute indices
-	// and return the corresponding value from the attribute table.
-	table := tCtx.GetProfilesDictionary().AttributeTable()
-	indices := tCtx.GetProfile().AttributeIndices().AsRaw()
-
-	for _, tableIndex := range indices {
-		attr := table.At(int(tableIndex))
-		if attr.Key() == key {
-			v := pcommon.NewValueEmpty()
-			attr.Value().CopyTo(v)
-			return v
-		}
-	}
-
-	return pcommon.NewValueEmpty()
-}

pkg/ottl/contexts/internal/ctxprofile/profile_test.go

@@ -205,8 +205,15 @@ func (p *profileContext) GetProfile() pprofile.Profile {
 	return p.profile
 }
 
+func (p *profileContext) AttributeIndices() pcommon.Int32Slice {
+	return p.profile.AttributeIndices()
+}
+
 func newProfileContext(profile pprofile.Profile, dictionary pprofile.ProfilesDictionary) *profileContext {
-	return &profileContext{profile: profile, dictionary: dictionary}
+	return &profileContext{
+		profile:    profile,
+		dictionary: dictionary,
+	}
 }
 
 func createValueTypeSlice() pprofile.ValueTypeSlice {

pkg/ottl/contexts/internal/ctxprofilecommon/attributes.go

@@ -0,0 +1,126 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+package ctxprofilecommon // import "github.com/open-telemetry/opentelemetry-collector-contrib/pkg/ottl/contexts/internal/ctxprofilecommon"
+
+import (
+	"context"
+
+	"go.opentelemetry.io/collector/pdata/pcommon"
+	"go.opentelemetry.io/collector/pdata/pprofile"
+
+	"github.com/open-telemetry/opentelemetry-collector-contrib/pkg/ottl"
+	"github.com/open-telemetry/opentelemetry-collector-contrib/pkg/ottl/contexts/internal/ctxutil"
+)
+
+type ProfileAttributeContext interface {
+	AttributeIndices() pcommon.Int32Slice
+	GetProfilesDictionary() pprofile.ProfilesDictionary
+}
+
+func AccessAttributes[K ProfileAttributeContext]() ottl.StandardGetSetter[K] {
+	return ottl.StandardGetSetter[K]{
+		Getter: func(_ context.Context, tCtx K) (any, error) {
+			return fromAttributeIndices(tCtx.GetProfilesDictionary().AttributeTable(), tCtx), nil
+		},
+		Setter: func(_ context.Context, tCtx K, val any) error {
+			m, err := ctxutil.GetMap(val)
+			if err != nil {
+				return err
+			}
+			for k, v := range m.All() {
+				if err := putAttribute(tCtx.GetProfilesDictionary().AttributeTable(), tCtx, k, v); err != nil {
+					return err
+				}
+			}
+			return nil
+		},
+	}
+}
+
+func AccessAttributesKey[K ProfileAttributeContext](key []ottl.Key[K]) ottl.StandardGetSetter[K] {
+	return ottl.StandardGetSetter[K]{
+		Getter: func(ctx context.Context, tCtx K) (any, error) {
+			return ctxutil.GetMapValue[K](ctx, tCtx, fromAttributeIndices(tCtx.GetProfilesDictionary().AttributeTable(), tCtx), key)
+		},
+		Setter: func(ctx context.Context, tCtx K, val any) error {
+			newKey, err := ctxutil.GetMapKeyName(ctx, tCtx, key[0])
+			if err != nil {
+				return err
+			}
+			v := getAttributeValue(tCtx, *newKey)
+			if err := ctxutil.SetIndexableValue[K](ctx, tCtx, v, val, key[1:]); err != nil {
+				return err
+			}
+			return putAttribute(tCtx.GetProfilesDictionary().AttributeTable(), tCtx, *newKey, v)
+		},
+	}
+}
+
+func getAttributeValue[K ProfileAttributeContext](tCtx K, key string) pcommon.Value {
+	// Find the index of the attribute in the profile's attribute indices
+	// and return the corresponding value from the attribute table.
+	table := tCtx.GetProfilesDictionary().AttributeTable()
+	indices := tCtx.AttributeIndices().AsRaw()
+
+	for _, tableIndex := range indices {
+		attr := table.At(int(tableIndex))
+		if attr.Key() == key {
+			v := pcommon.NewValueEmpty()
+			attr.Value().CopyTo(v)
+			return v
+		}
+	}
+
+	return pcommon.NewValueEmpty()
+}
+
+// fromAttributeIndices creates a pcommon.Map from the attribute indices in the provided context
+func fromAttributeIndices(attributeTable pprofile.AttributeTableSlice, ctx ProfileAttributeContext) pcommon.Map {
+	m := pcommon.NewMap()
+	indices := ctx.AttributeIndices().AsRaw()
+
+	for _, tableIndex := range indices {
+		if int(tableIndex) < attributeTable.Len() {
+			attr := attributeTable.At(int(tableIndex))
+			attr.Value().CopyTo(m.PutEmpty(attr.Key()))
+		}
+	}
+
+	return m
+}
+
+// putAttribute adds or updates an attribute in the attribute table and updates the context's attribute indices
+func putAttribute(attributeTable pprofile.AttributeTableSlice, ctx ProfileAttributeContext, key string, value pcommon.Value) error {
+	// First, check if the attribute already exists in the context's indices
+	indices := ctx.AttributeIndices()
+	existingIndex := -1
+
+	for i := 0; i < indices.Len(); i++ {
+		tableIndex := indices.At(i)
+		if int(tableIndex) < attributeTable.Len() {
+			attr := attributeTable.At(int(tableIndex))
+			if attr.Key() == key {
+				existingIndex = int(tableIndex)
+				break
+			}
+		}
+	}
+
+	if existingIndex >= 0 {
+		// Update existing attribute
+		attr := attributeTable.At(existingIndex)
+		value.CopyTo(attr.Value())
+	} else {
+		// Add new attribute to the table
+		newAttr := attributeTable.AppendEmpty()
+		newAttr.SetKey(key)
+		value.CopyTo(newAttr.Value())
+
+		// Add the new index to the context's attribute indices
+		newIndex := int32(attributeTable.Len() - 1)
+		indices.Append(newIndex)
+	}
+
+	return nil
+}

pkg/ottl/contexts/internal/ctxprofilecommon/attributes_test.go

@@ -0,0 +1,117 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+package ctxprofilecommon // import "github.com/open-telemetry/opentelemetry-collector-contrib/pkg/ottl/contexts/internal/ctxprofilecommon"
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"go.opentelemetry.io/collector/pdata/pcommon"
+	"go.opentelemetry.io/collector/pdata/pprofile"
+)
+
+// Mock implementations for AttributeContext and dependencies
+
+type mockAttributeContext struct {
+	indices    pcommon.Int32Slice
+	dictionary pprofile.ProfilesDictionary
+}
+
+func (m *mockAttributeContext) AttributeIndices() pcommon.Int32Slice {
+	return m.indices
+}
+
+func (m *mockAttributeContext) GetProfilesDictionary() pprofile.ProfilesDictionary {
+	return m.dictionary
+}
+
+func TestAccessAttributes_Getter(t *testing.T) {
+	dict := pprofile.NewProfilesDictionary()
+	attrTable := dict.AttributeTable()
+	attr1 := attrTable.AppendEmpty()
+	attr1.SetKey("foo")
+	attr1.Value().SetStr("bar")
+	attr2 := attrTable.AppendEmpty()
+	attr2.SetKey("baz")
+	attr2.Value().SetInt(42)
+
+	indices := pcommon.NewInt32Slice()
+	indices.Append(0)
+	indices.Append(1)
+
+	ctx := &mockAttributeContext{
+		indices:    indices,
+		dictionary: dict,
+	}
+
+	getSetter := AccessAttributes[*mockAttributeContext]()
+
+	got, err := getSetter.Getter(t.Context(), ctx)
+	assert.NoError(t, err)
+
+	m, ok := got.(pcommon.Map)
+	assert.True(t, ok)
+
+	fooValue, ok := m.Get("foo")
+	assert.True(t, ok)
+	assert.Equal(t, "bar", fooValue.Str())
+
+	bazValue, ok := m.Get("baz")
+	assert.True(t, ok)
+	assert.Equal(t, int64(42), bazValue.Int())
+}
+
+func TestAccessAttributes_Setter(t *testing.T) {
+	dict := pprofile.NewProfilesDictionary()
+	attrTable := dict.AttributeTable()
+	indices := pcommon.NewInt32Slice()
+
+	ctx := &mockAttributeContext{
+		indices:    indices,
+		dictionary: dict,
+	}
+
+	getSetter := AccessAttributes[*mockAttributeContext]()
+
+	// Prepare map to set
+	m := pcommon.NewMap()
+	m.PutStr("alpha", "beta")
+	m.PutInt("num", 123)
+
+	err := getSetter.Setter(t.Context(), ctx, m)
+	assert.NoError(t, err)
+
+	// Check that attributes were set in the table
+	foundAlpha := false
+	foundNum := false
+	for i := 0; i < attrTable.Len(); i++ {
+		attr := attrTable.At(i)
+		if attr.Key() == "alpha" {
+			foundAlpha = true
+			assert.Equal(t, "beta", attr.Value().Str())
+		}
+		if attr.Key() == "num" {
+			foundNum = true
+			assert.Equal(t, int64(123), attr.Value().Int())
+		}
+	}
+	assert.True(t, foundAlpha)
+	assert.True(t, foundNum)
+}
+
+func TestAccessAttributes_Setter_InvalidValue(t *testing.T) {
+	dict := pprofile.NewProfilesDictionary()
+	indices := pcommon.NewInt32Slice()
+
+	ctx := &mockAttributeContext{
+		indices:    indices,
+		dictionary: dict,
+	}
+
+	getSetter := AccessAttributes[*mockAttributeContext]()
+
+	// Pass a value that is not a ctxutil.Map
+	err := getSetter.Setter(t.Context(), ctx, "not_a_map")
+	assert.Error(t, err)
+}