[pkg/ottl] adapt mapGetter to handle nested map items within slices

.chloggen/ottl-nested-map-literals.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: bug_fix
+
+# 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: Fix limitation of map literals within slice literals not being handled correctly
+
+# Mandatory: One or more tracking issues related to the change. You can use the PR number here if no issue exists.
+issues: [37405]
+
+# (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: []

pkg/ottl/e2e/e2e_test.go

@@ -1084,6 +1084,30 @@ func Test_e2e_converters(t *testing.T) {
 				m.PutInt("bar", 5)
 			},
 		},
+		{
+			statement: `set(attributes["test"], {"list":[{"foo":"bar"}]})`,
+			want: func(tCtx ottllog.TransformContext) {
+				m := tCtx.GetLogRecord().Attributes().PutEmptyMap("test")
+				m2 := m.PutEmptySlice("list").AppendEmpty().SetEmptyMap()
+				m2.PutStr("foo", "bar")
+			},
+		},
+		{
+			statement: `set(attributes, {"list":[{"foo":"bar"}]})`,
+			want: func(tCtx ottllog.TransformContext) {
+				tCtx.GetLogRecord().Attributes().Clear()
+				m2 := tCtx.GetLogRecord().Attributes().PutEmptySlice("list").AppendEmpty().SetEmptyMap()
+				m2.PutStr("foo", "bar")
+			},
+		},
+		{
+			statement: `set(attributes["arr"], [{"list":[{"foo":"bar"}]}, {"bar":"baz"}])`,
+			want: func(tCtx ottllog.TransformContext) {
+				arr := tCtx.GetLogRecord().Attributes().PutEmptySlice("arr")
+				arr.AppendEmpty().SetEmptyMap().PutEmptySlice("list").AppendEmpty().SetEmptyMap().PutStr("foo", "bar")
+				arr.AppendEmpty().SetEmptyMap().PutStr("bar", "baz")
+			},
+		},
 	}
 
 	for _, tt := range tests {
@@ -1263,6 +1287,28 @@ func Test_e2e_ottl_value_expressions(t *testing.T) {
 			statement: `Hex(Len(attributes) + Len(attributes))`,
 			want:      "0000000000000018",
 		},
+		{
+			name:      "return map type",
+			statement: `attributes["foo"]`,
+			want: map[string]any{
+				"bar":   "pass",
+				"flags": "pass",
+				"slice": []any{
+					"val",
+				},
+				"nested": map[string]any{
+					"test": "pass",
+				},
+			},
+		},
+		{
+			name:      "return list",
+			statement: `attributes["things"]`,
+			want: []any{
+				map[string]any{"name": "foo", "value": int64(2)},
+				map[string]any{"name": "bar", "value": int64(5)},
+			},
+		},
 	}
 
 	for _, tt := range tests {

pkg/ottl/expression.go

@@ -169,6 +169,7 @@ func (l *listGetter[K]) Get(ctx context.Context, tCtx K) (any, error) {
 		if err != nil {
 			return nil, err
 		}
+
 		evaluated[i] = val
 	}
 
@@ -180,23 +181,37 @@ type mapGetter[K any] struct {
 }
 
 func (m *mapGetter[K]) Get(ctx context.Context, tCtx K) (any, error) {
-	evaluated := map[string]any{}
+	result := pcommon.NewMap()
 	for k, v := range m.mapValues {
 		val, err := v.Get(ctx, tCtx)
 		if err != nil {
 			return nil, err
 		}
-		switch t := val.(type) {
+		switch typedVal := val.(type) {
 		case pcommon.Map:
-			evaluated[k] = t.AsRaw()
+			target := result.PutEmpty(k).SetEmptyMap()
+			typedVal.CopyTo(target)
+		case []any:
+			target := result.PutEmpty(k).SetEmptySlice()
+			for _, el := range typedVal {
+				switch typedEl := el.(type) {
+				case pcommon.Map:
+					m := target.AppendEmpty().SetEmptyMap()
+					typedEl.CopyTo(m)
+				default:
+					err := target.AppendEmpty().FromRaw(el)
+					if err != nil {
+						return nil, err
+					}
+				}
+			}
 		default:
-			evaluated[k] = t
+			err := result.PutEmpty(k).FromRaw(val)
+			if err != nil {
+				return nil, err
+			}
 		}
 	}
-	result := pcommon.NewMap()
-	if err := result.FromRaw(evaluated); err != nil {
-		return nil, err
-	}
 	return result, nil
 }
 

pkg/ottl/expression_test.go

@@ -641,6 +641,16 @@ func Test_newGetter(t *testing.T) {
 																Int: ottltest.Intp(1),
 															},
 														},
+														{
+															Map: &mapValue{
+																Values: []mapItem{
+																	{
+																		Key:   ottltest.Strp("stringAttr"),
+																		Value: &value{String: ottltest.Strp("value")},
+																	},
+																},
+															},
+														},
 													},
 												},
 											},
@@ -660,7 +670,7 @@ func Test_newGetter(t *testing.T) {
 					"foo": map[string]any{
 						"test": "value",
 					},
-					"listAttr": []any{"test0", int64(1)},
+					"listAttr": []any{"test0", int64(1), map[string]any{"stringAttr": "value"}},
 				},
 				"stringAttr": "value",
 				"intAttr":    int64(3),

pkg/ottl/parser.go

@@ -12,6 +12,7 @@ import (
 
 	"github.com/alecthomas/participle/v2"
 	"go.opentelemetry.io/collector/component"
+	"go.opentelemetry.io/collector/pdata/pcommon"
 	"go.uber.org/zap"
 )
 
@@ -480,6 +481,29 @@ func (p *Parser[K]) ParseValueExpression(raw string) (*ValueExpression[K], error
 	}
 
 	return &ValueExpression[K]{
-		getter: getter,
+		getter: &StandardGetSetter[K]{
+			Getter: func(ctx context.Context, tCtx K) (any, error) {
+				val, err := getter.Get(ctx, tCtx)
+				if err != nil {
+					return nil, err
+				}
+				switch v := val.(type) {
+				case pcommon.Map:
+					return v.AsRaw(), nil
+				case pcommon.Slice:
+					return v.AsRaw(), nil
+				case []any:
+					for index, elem := range v {
+						// make sure also nested maps within a slice are returned in their raw form
+						if m, ok := elem.(pcommon.Map); ok {
+							v[index] = m.AsRaw()
+						}
+					}
+					return v, nil
+				default:
+					return v, nil
+				}
+			},
+		},
 	}, nil
 }

pkg/ottl/parser_test.go

@@ -16,7 +16,6 @@ import (
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 	"go.opentelemetry.io/collector/component/componenttest"
-	"go.opentelemetry.io/collector/pdata/pcommon"
 
 	"github.com/open-telemetry/opentelemetry-collector-contrib/pkg/ottl/ottltest"
 )
@@ -2209,11 +2208,9 @@ func Test_parseValueExpression_full(t *testing.T) {
 			name:            "map",
 			valueExpression: `{"map": 1}`,
 			expected: func() any {
-				m := pcommon.NewMap()
-				_ = m.FromRaw(map[string]any{
-					"map": 1,
-				})
-				return m
+				return map[string]any{
+					"map": int64(1),
+				}
 			},
 		},
 		{
@@ -2223,6 +2220,24 @@ func Test_parseValueExpression_full(t *testing.T) {
 				return []any{"list", "of", "strings"}
 			},
 		},
+		{
+			name:            "nested list",
+			valueExpression: `[{"list":[{"foo":"bar"}]}, {"bar":"baz"}]`,
+			expected: func() any {
+				return []any{
+					map[string]any{
+						"list": []any{
+							map[string]any{
+								"foo": "bar",
+							},
+						},
+					},
+					map[string]any{
+						"bar": "baz",
+					},
+				}
+			},
+		},
 	}
 
 	for _, tt := range tests {